wpf – could not load file or assembly ‘system.diagnostics.diagnosticsource

I created WPF application and it is running perfectly in Visual studio (VS 2019)(W10). I created a Setup Installer form Setup project in VS. It is installing application successfully, But this error popup when try to open installed software.

Could not load file or assembly ‘System.Diagnostics.DiagnosticSource, Version=, Culture=neutral, PublicKeyToken=””.the located assembly’s manifest definition does not match the assembly reference

enter image description here

C para Assembly Risc-V

Estou a fazer um editor de linha em Risc-V com as funções simples, insert, delete, read file, etc…

Existe algum compilador que passe c diretamente para Risc-V? Sei que existe para assembly normal, mas não encontro para Risc-V

graphics – I have some assembly code that makes the screen fade out on my MS-DOS game. It works, but it loops continuously

I am making a game with C and assembly for MS-DOS (I am planning to distribute the game with DOSBox or my own modification thereof). I large portions of the graphics code are in assembly, which is a language I am weaker in, but I saw it as something that was convenient to use due to its ability to change things to such a nitty-gritty level (down to things like the graphical palette and such).

However, I am basing my code off of a fade out function that I found from some old source code that was in 16 bit assembly, and I am trying to convert it to 32 bit assembly.

I got the code to work, but however, it keeps looping repeatedly instead of continuing the code.

AFObeg  equ (bp+4)
AFOcnt  equ (bp+4+2)

proc FadeOut_ near
    push    ebx
    push    ecx
    push    edx
    mov ebp,esp
    push    ds
    push    esi
    push    edi

    push    ds        ; get data segment into es
    pop es
    mov edx, offset _WorkPalette
    push    edx       ; save offset of opal
    xor ebx, ebx
    mov ecx, 100h
    mov eax, 1017h    ; bios read dac registers function
    int 10h       ; read the palette registers into opal
    pop edi       ; offset of opal, was in dx!
    mov eax, AFObeg   ; get offset of first palette byte to
    mov ebx, 3        ; be processed
    mul ebx
    add edi, eax          ; adjust offset into opal
    mov eax, AFOcnt   ; find the number of bytes to be processed
    mov ebx, 3
    mul ebx       ; leave it in ax
    mov ecx, 64       ; 64 passes through fade loop
    push    ecx       ; save the fade loop counter
    push    edi       ; save offset of first byte processed in
    mov bl, cl        ; we'll use the pass number as a threshold
    mov ecx, eax          ; load number of bytes to process into cx
    cmp bl, es:(edi)      ; start decrementing when palette value
    jnz o_no_dec      ; is equal loop count (it will stay equal
    dec BYTE PTR es:(edi)  ; to loop count for the rest of this pass)
    inc edi
    loop    o_pal_cmp_loop      ; do the next byte

    mov ebx, esp            ; need the stack pointer for a moment
    mov di, ss:(ebx)        ; restore offset into pal without popping
    mov ecx, AFOcnt     ; number of triplets to process
    push    eax         ; need to use ax for port i/o

        mov edx, 03DAh      ; CRT controller input status 1 register
        in al, dx           ; watch vertical blanking bit
        test al,08h         ; wait for it to clear to make sure
        jnz o_vbi_1         ; we're not in a blanking interval
        in al, dx           ; now wait for the start of the
        test al,08h         ; next blanking interval
        jz o_vbi_2

    mov ah, AFObeg ; get first register to process into ah
    mov dx, 03c8h       ; DAC palette index register
    mov al, ah          ; get next palette number to write
    out dx, al          ; write the register number to the dac
    inc dx          ; address dac data register
    mov al, BYTE PTR es:(di) ; get first byte of triplet
    out dx, al           ; write it to the dac data register
    inc edi          ; point to second byte
    mov al, BYTE PTR es:(di) ; get second byte of triplet
    out dx, al           ; write it to the dac data register
    inc edi          ; point to third byte
    mov al, BYTE PTR es:(di) ; get third byte of triplet
    out dx, al           ; write it to the dac data register
    inc edi          ; point to first byte of next triplet
    dec edx          ; address the da21c index register
    inc ah           ; point to next palette register
    loop    o_pal_load_loop      ; process next triplet

    pop eax       ; restore ax
    pop edi       ; restore the offset into pal
    pop ecx       ; restore the fade loop counter
    loop    o_fade_loop   ; do the next pass through the fade loop

    pop edi
    pop esi
    pop ds
    pop ebp
    endp ;end of the fade out function

If anyone has any more questions, I will gladly answer them.

dotnetcore – SpecFlow LivingDoc report not successfully generated – Could not load file or assembly ‘TechTalk.SpecFlow

I’m trying to generate the livingDoc report by using this command:

livingdoc test-assembly .dll -t TestExecution.json

I’m getting the following warning:

Framework: .NET 5.0.6
Warning: Could not load file or assembly ‘TechTalk.SpecFlow, Version=, Culture=neutral, PublicKeyToken=0778194805d6db41’. Could not find or load a specific file. (0x80131621)

The LivingDoc report is generated but all the scenarios within the report are marked as ‘Skipped’.

Sincronizar Arquivos Executáveis de Jogo de luta em Assembly ou C++

Quero sincronizar um jogo de luta em dois PCs diferentes. São dois arquivos idênticos rodando em duas máquinas diferentes. Tenho conhecimento intermediário em C++ e Assembly. E tenho acesso somente ao código objeto. Fiz engenharia reversa no jogo e consigo injetar meu código assembly no código do jogo e se for preciso também consigo ler e escrever em endereços específicos da memória. A ideia é usar uma máquina como servidor (referência) e a outra como cliente. Minhas dúvidas são:

  1. Qual seria a melhor maneira de sincronizar os arquivos executáveis para que não exista lag no jogo? E como isso deveria ser feito?
  2. Eu pensei em injetar algum código assembly para desviar o fluxo do programa para ler o registrador EIP, disponibilizar essa informação em algum endereço da memória e criar outro processo para ler esse dado e mandar a informação para o cliente desviar o programa para o mesmo ponto do código, isso é viável?

Qualquer ideia ou sugestão é muito bem vinda e sou muito grato pelas respostas.


Write the MIPS Assembly Code for this expression. Assume that A is in $S5, and B is in $S7

𝐴(25) = ((𝑎 ∗ 𝐶/512 + 𝑙 ∗ 𝑏) |16)&(𝐴|𝐵 ∗ 𝐶/16 − 𝐵(18))

This code can be converted into C or other new language but MIPS 32 is pretty hard for me.

How do I convert it into MIPS assembly language? Please help! I am literally a beginner in assembly

This code can be converted into C or other new language but MIPS 32 is pretty hard for me.

memory hardware – Assembly Language Step By Step: Why deviate from the norm and design computers where the presence of voltage encodes a 0 bit?

That the presence of voltage across a switch encodes 12 is purely arbitrary… Jeff Duntemann’s book mentions:

We could as well have said that the lack of voltage indicates a binary
1 and vice versa (and computers have been built this way for obscure

I find this (italicized part) quite fascinating. It would be great if someone could shed some light on what “obscure” reason(s) may motivate people to do so?

android – what do these assembly code doing?

    00100e44 08  00  40  f9    ldr        x8, [param_1 ]

This load the value at memory address param_1 into register x8.

    00100e48 01  00  00  b0    adrp       x1, s_c7a584936712f32773d3d0a_00101000  

This sets register x1 to 0x101000.

    00100e4c 21  60  08  91    add        x1, x1, #0x218

This adds 0x218 to x1, so sets x1 to 0x101218.

    00100e50 02  9d  42  f9    ldr        x2, [x8, #0x538 ]

This loads the value at x8 + 0x538 into x2.

    00100e54 40  00  1f  d6    br         x2

This branches to the memory address stored in x2.

So, unless I am missing something, it looks like there may not be enough information to say what happens unless you provide the additional disassembly at x2. It might be easier to figure out if you can step through the code with a debugger rather than via static analysis.