LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_ExtractAndAddBytes
void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int lanePosition = offset/8;
    unsigned int offsetInLane = offset%8;

    assert(offset < 200);
    assert(offset+length <= 200);
    while(length > 0) {
        unsigned int bytesInLane = 8 - offsetInLane;
        if (bytesInLane > length)
            bytesInLane = length;
        KeccakP1600_ExtractAndAddBytesInLane(state, lanePosition, input, output, offsetInLane, bytesInLane);
        length -= bytesInLane;
        lanePosition++;
        offsetInLane = 0;
        input += bytesInLane;
        output += bytesInLane;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movl 0x1c(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x10(%rsp)
cmpl $0xc8, 0x1c(%rsp)
jae 0x6efe
jmp 0x6f1d
leaq 0x100fb(%rip), %rdi     # 0x17000
leaq 0x10101(%rip), %rsi     # 0x1700d
movl $0x222, %edx            # imm = 0x222
leaq 0x102e3(%rip), %rcx     # 0x171fb
callq 0x51b0
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
cmpl $0xc8, %eax
ja 0x6f2e
jmp 0x6f4d
leaq 0x101b1(%rip), %rdi     # 0x170e6
leaq 0x100d1(%rip), %rsi     # 0x1700d
movl $0x223, %edx            # imm = 0x223
leaq 0x102b3(%rip), %rcx     # 0x171fb
callq 0x51b0
jmp 0x6f4f
cmpl $0x0, 0x18(%rsp)
jbe 0x6fe7
movl $0x8, %eax
subl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jbe 0x6f79
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0x10(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq 0x5240
movl 0xc(%rsp), %ecx
movl 0x18(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x6f4f
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_DisplayRoundConstants
void KeccakP1600_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%08X:%08X", (unsigned int)(KeccakRoundConstants[i][0]), (unsigned int)(KeccakRoundConstants[i][1]));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x18, 0xc(%rsp)
jae 0x7073
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0x10259(%rip), %rsi     # 0x17271
movb $0x0, %al
callq 0x5710
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x1027f(%rip), %rax     # 0x172b0
movl (%rax,%rcx,8), %edx
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x1026f(%rip), %rax     # 0x172b0
movl 0x4(%rax,%rcx,8), %ecx
leaq 0x10237(%rip), %rsi     # 0x17283
movb $0x0, %al
callq 0x5710
movq 0x10(%rsp), %rdi
leaq 0x10cba(%rip), %rsi     # 0x17d19
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7001
movq 0x10(%rsp), %rdi
leaq 0x10c9a(%rip), %rsi     # 0x17d19
movb $0x0, %al
callq 0x5710
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_DisplayRhoOffsets
void KeccakP1600_DisplayRhoOffsets(FILE *f)
{
    unsigned int x, y;

    for(y=0; y<5; y++) for(x=0; x<5; x++) {
        fprintf(f, "RhoOffset[%i][%i] = ", x, y);
        fprintf(f, "%2i", KeccakRhoOffsets[5*y+x]);
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x5, 0x8(%rsp)
jae 0x7132
movl $0x0, 0xc(%rsp)
cmpl $0x5, 0xc(%rsp)
jae 0x7120
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
leaq 0x101be(%rip), %rsi     # 0x1728d
movb $0x0, %al
callq 0x5710
movq 0x10(%rsp), %rdi
imull $0x5, 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x10281(%rip), %rax     # 0x17370
movl (%rax,%rcx,4), %edx
leaq 0x101a9(%rip), %rsi     # 0x172a2
movb $0x0, %al
callq 0x5710
movq 0x10(%rsp), %rdi
leaq 0x10c0d(%rip), %rsi     # 0x17d19
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x70b4
jmp 0x7122
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x70a1
movq 0x10(%rsp), %rdi
leaq 0x10bdb(%rip), %rsi     # 0x17d19
movb $0x0, %al
callq 0x5710
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-800-reference.c
// Function: KeccakP800_AddBytes
void KeccakP800_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 100);
    assert(offset+length <= 100);
    for(i=0; i<length; i++)
        ((unsigned char *)state)[offset+i] ^= data[i];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x64, 0x14(%rsp)
jae 0x9a9f
jmp 0x9abe
leaq 0xdf1e(%rip), %rdi      # 0x179c4
leaq 0xdf24(%rip), %rsi      # 0x179d1
movl $0x98, %edx
leaq 0xdf96(%rip), %rcx      # 0x17a4f
callq 0x51b0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0x64, %eax
ja 0x9acd
jmp 0x9aec
leaq 0xdfcf(%rip), %rdi      # 0x17aa3
leaq 0xdef6(%rip), %rsi      # 0x179d1
movl $0x99, %edx
leaq 0xdf68(%rip), %rcx      # 0x17a4f
callq 0x51b0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x9b30
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl 0xc(%rsp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9af4
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-800-reference.c
// Function: KeccakP800_ExtractAndAddBytes
void KeccakP800_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 100);
    assert(offset+length <= 100);
    for(i=0; i<length; i++)
        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
cmpl $0x64, 0xc(%rsp)
jae 0xa4b5
jmp 0xa4d4
leaq 0xd508(%rip), %rdi      # 0x179c4
leaq 0xd50e(%rip), %rsi      # 0x179d1
movl $0x16c, %edx            # imm = 0x16C
leaq 0xd6e6(%rip), %rcx      # 0x17bb5
callq 0x51b0
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0x64, %eax
ja 0xa4e3
jmp 0xa502
leaq 0xd5b9(%rip), %rdi      # 0x17aa3
leaq 0xd4e0(%rip), %rsi      # 0x179d1
movl $0x16d, %edx            # imm = 0x16D
leaq 0xd6b8(%rip), %rcx      # 0x17bb5
callq 0x51b0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0xa551
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %edx
addl 0x4(%rsp), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa50a
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-800-reference.c
// Function: KeccakP800_DisplayRoundConstants
void KeccakP800_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i]));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x16, 0xc(%rsp)
jae 0xa5d2
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0xcce9(%rip), %rsi      # 0x17271
movb $0x0, %al
callq 0x5710
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xd68f(%rip), %rax      # 0x17c30
movl (%rax,%rcx,4), %edx
leaq 0xccdd(%rip), %rsi      # 0x17288
movb $0x0, %al
callq 0x5710
movq 0x10(%rsp), %rdi
leaq 0xd75b(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa571
movq 0x10(%rsp), %rdi
leaq 0xd73b(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayBytes
void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size)
{
    unsigned int i;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<size; i++)
            fprintf(intermediateValueFile, "%02X ", bytes[i]);
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x63b3(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x15ceb
movl 0x24(%rsp), %eax
movq 0x63a6(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x15ceb
movq 0x638f(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x2084(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x15cbb
movq 0x6360(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movzbl (%rax,%rcx), %edx
leaq 0x2052(%rip), %rsi      # 0x17cf9
movb $0x0, %al
callq 0x5710
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x15c7f
movq 0x632e(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x204d(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
movq 0x6316(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x2035(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayBits
void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst)
{
    unsigned int i, iByte, iBit;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<size; i++) {
            iByte = i/8;
            iBit = i%8;
            if (MSBfirst)
                fprintf(intermediateValueFile, "%d ", ((data[iByte] << iBit) & 0x80) != 0);
            else
                fprintf(intermediateValueFile, "%d ", ((data[iByte] >> iBit) & 0x01) != 0);
        }
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq 0x62de(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x15e37
movl 0x34(%rsp), %eax
movq 0x62d1(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x15e37
movq 0x62ba(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1faf(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x15e07
movl 0x14(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x15dbc
movq 0x626a(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x10(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl 0xc(%rsp), %ecx
shll %cl, %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x1f4c(%rip), %rsi      # 0x17cff
movb $0x0, %al
callq 0x5710
jmp 0x15df5
movq 0x622d(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x10(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl 0xc(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x1f11(%rip), %rsi      # 0x17cff
movb $0x0, %al
callq 0x5710
jmp 0x15df7
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x15d54
movq 0x61e2(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1f01(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
movq 0x61ca(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1ee9(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs32bitWords
void displayStateAs32bitWords(int level, const char *text, const unsigned int *state)
{
    unsigned int i;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%08X:%08X", (unsigned int)state[2*i+0], (unsigned int)state[2*i+1]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
            else
                fprintf(intermediateValueFile, " ");
        }
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x6157(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x15f7c
movl 0x24(%rsp), %eax
movq 0x614a(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x15f7c
movq 0x6133(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1e28(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0xc(%rsp)
cmpl $0x19, 0xc(%rsp)
jae 0x15f7a
movq 0x6103(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shll %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %ecx
leaq 0x1366(%rip), %rsi      # 0x17283
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x4, %edx
jne 0x15f50
movq 0x60b3(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1dd2(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
jmp 0x15f68
movq 0x6099(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1320(%rip), %rsi      # 0x17281
movb $0x0, %al
callq 0x5710
jmp 0x15f6a
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15edb
jmp 0x15f7c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs64bitLanes
void displayStateAs64bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned long long int *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] >> 32));
            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] & 0xFFFFFFFFULL));
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
            else
                fprintf(intermediateValueFile, " ");
        }
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x603e(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x160b3
movl 0x24(%rsp), %eax
movq 0x6031(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x160b3
movq 0x601a(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1d0f(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0xc(%rsp)
cmpl $0x19, 0xc(%rsp)
jae 0x160b1
movq 0x5fea(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movl %eax, %edx
leaq 0x1266(%rip), %rsi      # 0x17288
movb $0x0, %al
callq 0x5710
movq 0x5fc0(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
movl %eax, %edx
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq (%rcx,%rdx,8), %rax
movl %eax, %edx
leaq 0x1234(%rip), %rsi      # 0x17288
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x4, %edx
jne 0x16087
movq 0x5f7c(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1c9b(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
jmp 0x1609f
movq 0x5f62(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x11e9(%rip), %rsi      # 0x17281
movb $0x0, %al
callq 0x5710
jmp 0x160a1
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15ff4
jmp 0x160b3
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs32bitLanes
void displayStateAs32bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned int *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%08X", state[i]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
            else
                fprintf(intermediateValueFile, " ");
        }
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x5f0e(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x161a3
movl 0x24(%rsp), %eax
movq 0x5f01(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x161a3
movq 0x5eea(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1bdf(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0xc(%rsp)
cmpl $0x19, 0xc(%rsp)
jae 0x161a1
movq 0x5ebe(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl (%rax,%rcx,4), %edx
leaq 0x1141(%rip), %rsi      # 0x17288
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x4, %edx
jne 0x1617a
movq 0x5e89(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1ba8(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
jmp 0x16192
movq 0x5e6f(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x10f6(%rip), %rsi      # 0x17281
movb $0x0, %al
callq 0x5710
jmp 0x16194
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16124
jmp 0x161a3
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs16bitLanes
void displayStateAs16bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned short *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%04X ", state[i]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
        }
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x5e1e(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x1627a
movl 0x24(%rsp), %eax
movq 0x5e11(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x1627a
movq 0x5dfa(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1aef(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0xc(%rsp)
cmpl $0x19, 0xc(%rsp)
jae 0x16278
movq 0x5dce(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movzwl (%rax,%rcx,2), %edx
leaq 0x1acb(%rip), %rsi      # 0x17d03
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x4, %edx
jne 0x16269
movq 0x5d98(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1ab7(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
jmp 0x1626b
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16214
jmp 0x1627a
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs8bitLanes
void displayStateAs8bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned char *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%02X ", state[i]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
        }
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x5d4e(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x1634a
movl 0x24(%rsp), %eax
movq 0x5d41(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x1634a
movq 0x5d2a(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1a1f(%rip), %rsi      # 0x17cf4
movb $0x0, %al
callq 0x5710
movl $0x0, 0xc(%rsp)
cmpl $0x19, 0xc(%rsp)
jae 0x16348
movq 0x5cfe(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %edx
leaq 0x19f1(%rip), %rsi      # 0x17cf9
movb $0x0, %al
callq 0x5710
movl 0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x4, %edx
jne 0x16339
movq 0x5cc8(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x19e7(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
jmp 0x1633b
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x162e4
jmp 0x1634a
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAsLanes
void displayStateAsLanes(int level, const char *text, void *statePointer, unsigned int width)
{
    if (width == 1600)
        displayStateAs64bitLanes(level, text, statePointer);
    if (width == 800)
        displayStateAs32bitLanes(level, text, statePointer);
    if (width == 400)
        displayStateAs16bitLanes(level, text, statePointer);
    if (width == 200)
        displayStateAs8bitLanes(level, text, statePointer);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
cmpl $0x640, 0xc(%rsp)       # imm = 0x640
jne 0x16383
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x55f0
cmpl $0x320, 0xc(%rsp)       # imm = 0x320
jne 0x163a0
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5430
cmpl $0x190, 0xc(%rsp)       # imm = 0x190
jne 0x163bd
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5380
cmpl $0xc8, 0xc(%rsp)
jne 0x163da
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5630
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayRoundNumber
void displayRoundNumber(int level, unsigned int i)
{
    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "--- Round %d ---\n", i);
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
movq 0x5c01(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x1644f
movl 0x4(%rsp), %eax
movq 0x5bf8(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x1644f
movq 0x5be5(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1904(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
movq 0x5bcd(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movl (%rsp), %edx
leaq 0x18d9(%rip), %rsi      # 0x17d09
movb $0x0, %al
callq 0x5710
movq 0x5bb2(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x18d1(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayText
void displayText(int level, const char *text)
{
    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s", text);
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x5b7c(%rip), %rax      # 0x1bff0
cmpq $0x0, (%rax)
je 0x164d6
movl 0x14(%rsp), %eax
movq 0x5b73(%rip), %rcx      # 0x1bff8
cmpl (%rcx), %eax
jg 0x164d6
movq 0x5b60(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x187c(%rip), %rsi      # 0x17d1b
movb $0x0, %al
callq 0x5710
movq 0x5b43(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x1862(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
movq 0x5b2b(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x184a(%rip), %rsi      # 0x17d19
movb $0x0, %al
callq 0x5710
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_add.c
// Function: shmem_int_atomic_add
void shmem_int_atomic_add( int* ptr, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe );
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	*remote_ptr = __sum(*remote_ptr,val);
	__clear_spin_lock(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x2010
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
leaq 0x2fd4(%rip), %rdi      # 0x71e0
addq $0x10, %rdi
callq 0x2010
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4570
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x4530
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_12/copy_io_nl.c
// Function: main
int main()
{
  int character;
  int previous_character = EOF;

  while ((character = getchar()) != EOF) {
    if (character == ' ' || character == '\t' || character == '\n') {
      if (previous_character != ' ' && previous_character != '\t' && previous_character != '\n') {
        putchar('\n');
      }
    }
    else {
      putchar(character);
    }

    previous_character = character;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x11b3
cmpl $0x20, -0x8(%rbp)
je 0x1185
cmpl $0x9, -0x8(%rbp)
je 0x1185
cmpl $0xa, -0x8(%rbp)
jne 0x11a3
cmpl $0x20, -0xc(%rbp)
je 0x11a1
cmpl $0x9, -0xc(%rbp)
je 0x11a1
cmpl $0xa, -0xc(%rbp)
je 0x11a1
movl $0xa, %edi
callq 0x1030
jmp 0x11ab
movl -0x8(%rbp), %edi
callq 0x1030
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x1166
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: blank
static int
blank (short int *c, int size)
{
    int     i;

    for (i = 0; i < size; i++) {
        if (c [i] != -1) {
            return (0);
        }
    }
    return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3ae1
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $-0x1, %eax
je 0x3ad4
movl $0x0, -0x4(%rbp)
jmp 0x3ae8
jmp 0x3ad6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ab2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: writerim
static  void
writerim (void)
{
    char    fname [PATH_MAX];
    char    leader [LEADER_LENGTH];
    FILE    *fp;
    int     i;

    // create the filename and open it
    sprintf (fname, "%s.rim", tapename);
    if ((fp = fopen (fname, "w")) == NULL) {
        fprintf (stderr, "%s:  unable to open RIM output file %s for w, errno %d (%s); creation of output file skipped\n", progname, fname, errno, strerror (errno));
        return;
    }

    // write leader
    memset (leader, 0x80, sizeof (leader));
    fwrite (leader, 1, sizeof (leader), fp);

    for (i = 0; i < CORE_SIZE; i++) {
        if (core [i] != -1) {
            fprintf (fp, "%c%c%c%c", 0x40 + ((i & 07700) >> 6), i & 00077, (core [i] & 07700) >> 6, core [i] & 00077);
        }
    }

    // write trailer
    fwrite (leader, 1, sizeof (leader), fp);

    fclose (fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
leaq -0x1000(%rbp), %rdi
movq 0xf0f7(%rip), %rdx      # 0x12f70
leaq 0x4b4c(%rip), %rsi      # 0x89cc
movb $0x0, %al
callq 0x3180
leaq -0x1000(%rbp), %rdi
leaq 0x515d(%rip), %rsi      # 0x8ff2
callq 0x3140
movq %rax, -0x1018(%rbp)
cmpq $0x0, %rax
jne 0x3f1f
movq 0xa14a(%rip), %rax      # 0xdff8
movq (%rax), %rax
movq %rax, -0x1038(%rbp)
movq 0xa241(%rip), %rax      # 0xe100
movq %rax, -0x1030(%rbp)
leaq -0x1000(%rbp), %rax
movq %rax, -0x1028(%rbp)
callq 0x3050
movl (%rax), %eax
movl %eax, -0x1020(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x31b0
movq -0x1038(%rbp), %rdi
movq -0x1030(%rbp), %rdx
movq -0x1028(%rbp), %rcx
movl -0x1020(%rbp), %r8d
movq %rax, %r9
leaq 0x4ac0(%rip), %rsi      # 0x89d3
movb $0x0, %al
callq 0x30f0
jmp 0x4027
leaq -0x1010(%rbp), %rdi
movl $0x80, %esi
movl $0x10, %edx
callq 0x30b0
leaq -0x1010(%rbp), %rdi
movq -0x1018(%rbp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x31a0
movl $0x0, -0x101c(%rbp)
cmpl $0x1000, -0x101c(%rbp)  # imm = 0x1000
jge 0x3ffe
movslq -0x101c(%rbp), %rcx
leaq 0xafe6(%rip), %rax      # 0xef60
movswl (%rax,%rcx,2), %eax
cmpl $-0x1, %eax
je 0x3fe8
movq -0x1018(%rbp), %rdi
movl -0x101c(%rbp), %edx
andl $0xfc0, %edx            # imm = 0xFC0
sarl $0x6, %edx
addl $0x40, %edx
movl -0x101c(%rbp), %ecx
andl $0x3f, %ecx
movslq -0x101c(%rbp), %rsi
leaq 0xafad(%rip), %rax      # 0xef60
movswl (%rax,%rsi,2), %r8d
andl $0xfc0, %r8d            # imm = 0xFC0
sarl $0x6, %r8d
movslq -0x101c(%rbp), %rsi
leaq 0xaf8f(%rip), %rax      # 0xef60
movswl (%rax,%rsi,2), %r9d
andl $0x3f, %r9d
leaq 0x4a50(%rip), %rsi      # 0x8a31
movb $0x0, %al
callq 0x30f0
jmp 0x3fea
movl -0x101c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x101c(%rbp)
jmp 0x3f5c
leaq -0x1010(%rbp), %rdi
movq -0x1018(%rbp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x31a0
movq -0x1018(%rbp), %rdi
callq 0x3080
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: checkrim
static int
checkrim (unsigned char *t, int n)
{
    int     i;

    if (n % 4) {
        if (optv > 2) {
            printf ("%s:  tape %s size (%d bytes) is not divisible by four; not a RIM tape\n", progname, tapename, n);
        }
        return (0);
    }

    // see if it's a RIM-formatted tape; we're looking for 01xxxxxx 00xxxxxx 00xxxxxx 00xxxxxx
    for (i = 0; i < n; i += 4) {
        if ((t [i] & 0xC0) != 0x40 || (t [i + 1] & 0xC0) || (t [i + 2] & 0xC0) || (t [i + 3] & 0xC0)) {
            if (optv > 2) {
                printf ("%s:  tape %s does not have the RIM signature at offset 0%04o; expected 01xxxxxx 00xxxxxx 00xxxxxx 00xxxxxx, got 0%04o 0%04o 0%04o 0%04o\n", progname, tapename, i, t [i], t [i + 1], t [i + 2], t [i + 3]);
            }
            return (0);
        }
    }
    return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4223
cmpl $0x2, 0xad5a(%rip)      # 0xef50
jle 0x4217
movq 0x9f01(%rip), %rsi      # 0xe100
movq 0xed6a(%rip), %rdx      # 0x12f70
movl -0x14(%rbp), %ecx
leaq 0x4442(%rip), %rdi      # 0x8652
movb $0x0, %al
callq 0x30a0
movl $0x0, -0x4(%rbp)
jmp 0x432f
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4328
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0x40, %eax
jne 0x429d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
jne 0x429d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
jne 0x429d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x4318
cmpl $0x2, 0xacac(%rip)      # 0xef50
jle 0x430f
movq 0x9e53(%rip), %rsi      # 0xe100
movq 0xecbc(%rip), %rdx      # 0x12f70
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdi
movzbl (%rax,%rdi), %r8d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %edi
addl $0x1, %edi
movslq %edi, %rdi
movzbl (%rax,%rdi), %r9d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %edi
addl $0x2, %edi
movslq %edi, %rdi
movzbl (%rax,%rdi), %r10d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %edi
addl $0x3, %edi
movslq %edi, %rdi
movzbl (%rax,%rdi), %eax
leaq 0x4399(%rip), %rdi      # 0x8699
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x30a0
movl $0x0, -0x4(%rbp)
jmp 0x432f
jmp 0x431a
movl -0x18(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x18(%rbp)
jmp 0x422a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: checkbin
static int
checkbin (unsigned char *t, int n)
{
    if (n % 2) {
        if (optv > 2) {
            printf ("%s:  tape %s size (%d bytes) is not divisible by two; not a BIN tape\n", progname, tapename, n);
        }
        return (0);
    }

    // see if it's a BIN-formatted tape; 01xxxxxx 00xxxxxx (i.e., we at least expect an origin)
    if ((t [0] & 0xC0) != 0x40 || (t [1] & 0xC0)) {
        if (optv > 2) {
            printf ("%s:  tape %s does not have the BIN origin signature; expected header of 01xxxxxx 00xxxxxx, got 0%04o 0%04o\n", progname, tapename, t [0], t [1]);
        }
        return (0);
    }

    return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4560
cmpl $0x2, 0xaa1a(%rip)      # 0xef50
jle 0x4557
movq 0x9bc1(%rip), %rsi      # 0xe100
movq 0xea2a(%rip), %rdx      # 0x12f70
movl -0x14(%rbp), %ecx
leaq 0x429b(%rip), %rdi      # 0x87eb
movb $0x0, %al
callq 0x30a0
movl $0x0, -0x4(%rbp)
jmp 0x45c8
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
cmpl $0x40, %eax
jne 0x4583
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x45c1
cmpl $0x2, 0xa9c6(%rip)      # 0xef50
jle 0x45b8
movq 0x9b6d(%rip), %rsi      # 0xe100
movq 0xe9d6(%rip), %rdx      # 0x12f70
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %r8d
leaq 0x4280(%rip), %rdi      # 0x8831
movb $0x0, %al
callq 0x30a0
movl $0x0, -0x4(%rbp)
jmp 0x45c8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: seg_more
static void
seg_more (int len)
{
    if (optv > 3) {
        printf ("seg_more (+%d (0%04o))\n", len, len);
    }

    if (nsegments) {
        segments [nsegments - 1].nwords += len;
    } else {
        fprintf (stderr, "%s:  seg_more called with no segments in existence\n", progname);
        exit (EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x3, 0xa63e(%rip)      # 0xef50
jle 0x4928
movl -0x4(%rbp), %esi
movl -0x4(%rbp), %edx
leaq 0x3e09(%rip), %rdi      # 0x872a
movb $0x0, %al
callq 0x30a0
cmpl $0x0, 0xe639(%rip)      # 0x12f68
je 0x4955
movl -0x4(%rbp), %esi
movq 0xe625(%rip), %rax      # 0x12f60
movl 0xe627(%rip), %ecx      # 0x12f68
subl $0x1, %ecx
movslq %ecx, %rcx
movzwl 0x2(%rax,%rcx,4), %edx
addl %esi, %edx
movw %dx, 0x2(%rax,%rcx,4)
jmp 0x497e
movq 0x969c(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x979a(%rip), %rdx      # 0xe100
leaq 0x3dd5(%rip), %rsi      # 0x8742
movb $0x0, %al
callq 0x30f0
movl $0x1, %edi
callq 0x3190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: seg_add
static void
seg_add (uint16_t addr, int len)
{
    if (optv > 3) {
        printf ("seg_add (0%04o, %d (0%04o))\n", addr, len, len);
    }

    segments = realloc (segments, (nsegments + 1) * sizeof (segments [0]));
    if (segments == NULL) {
        fprintf (stderr, "%s:  couldn't realloc segments array to be %d elements (%ld bytes) long, errno %d (%s)\n", progname, nsegments + 1, (unsigned long)(nsegments + 1) * sizeof (segments [0]), errno, strerror (errno));
        exit (EXIT_FAILURE);
    }
    segments [nsegments].saddr = addr;
    segments [nsegments].nwords = len;
    nsegments++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x3, 0xa5a7(%rip)      # 0xef50
jle 0x49c3
movzwl -0x2(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x3dba(%rip), %rdi      # 0x8776
movb $0x0, %al
callq 0x30a0
movq 0xe596(%rip), %rdi      # 0x12f60
movl 0xe598(%rip), %eax      # 0x12f68
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3120
movq %rax, 0xe57a(%rip)      # 0x12f60
cmpq $0x0, 0xe572(%rip)      # 0x12f60
jne 0x4a6d
movq 0x9601(%rip), %rax      # 0xdff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x96fb(%rip), %rax      # 0xe100
movq %rax, -0x28(%rbp)
movl 0xe559(%rip), %eax      # 0x12f68
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl 0xe54d(%rip), %eax      # 0x12f68
addl $0x1, %eax
cltq
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
callq 0x3050
movl (%rax), %eax
movl %eax, -0xc(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x31b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %r8
movl -0xc(%rbp), %r9d
leaq 0x3d3b(%rip), %rsi      # 0x8793
movq %rax, (%rsp)
movb $0x0, %al
callq 0x30f0
movl $0x1, %edi
callq 0x3190
movw -0x2(%rbp), %dx
movq 0xe4e8(%rip), %rax      # 0x12f60
movslq 0xe4e9(%rip), %rcx      # 0x12f68
movw %dx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
movw %ax, %dx
movq 0xe4d0(%rip), %rax      # 0x12f60
movslq 0xe4d1(%rip), %rcx      # 0x12f68
movw %dx, 0x2(%rax,%rcx,4)
movl 0xe4c6(%rip), %eax      # 0x12f68
addl $0x1, %eax
movl %eax, 0xe4bd(%rip)      # 0x12f68
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: ea
int
ea (int addr, int opcode, int *indirect, int *curpage)
{
    int     eff_addr;
    int     c;
    int     i;

    if (opcode >= 06000) {          // IOTs and OPRs don't have an EA
        return (-1);
    }

    i = opcode & 00400;
    c = opcode & 00200;
    eff_addr = c ? (addr & 07600) + (opcode & 00177) : opcode & 00177;
    if (indirect) {
        *indirect = i;
    }
    if (curpage) {
        *curpage = c;
    }
    return (eff_addr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0xc00, -0xc(%rbp)      # imm = 0xC00
jl 0x5c64
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5cca
movl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
andl $0x80, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x5c95
movl -0x8(%rbp), %eax
andl $0xf80, %eax            # imm = 0xF80
movl -0xc(%rbp), %ecx
andl $0x7f, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
jmp 0x5c9e
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5cb4
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x5cc4
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: fetch_iot
int
fetch_iot (int code, char *dis, char *com)
{
    int     i;

    for (i = 0; i < sizeof (iots) / sizeof (iots [0]); i++) {
        if (code == iots [i].code) {
            if (dis) {
                strcpy (dis, iots [i].mnemonic);
            }
            if (com) {
                strncpy (com, iots [i].comment, COMLEN - 1);
            }
            return (1);
        }
    }
    if (dis) {
        sprintf (dis, "%04o", code);
    }
    if (com) {
        sprintf (com, "unknown IOT");
    }
    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x6f, %rax
jae 0x5f9b
movl -0x8(%rbp), %eax
movslq -0x1c(%rbp), %rdx
leaq 0x81ea(%rip), %rcx      # 0xe110
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x5f8b
cmpq $0x0, -0x10(%rbp)
je 0x5f57
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x81c9(%rip), %rax      # 0xe110
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x3070
cmpq $0x0, -0x18(%rbp)
je 0x5f82
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x81a3(%rip), %rax      # 0xe110
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
movl $0x24, %edx
callq 0x3060
movl $0x1, -0x4(%rbp)
jmp 0x5fd7
jmp 0x5f8d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5f0a
cmpq $0x0, -0x10(%rbp)
je 0x5fb7
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0x5a0c(%rip), %rsi      # 0xb9bc
movb $0x0, %al
callq 0x3180
cmpq $0x0, -0x18(%rbp)
je 0x5fd0
movq -0x18(%rbp), %rdi
leaq 0x59f8(%rip), %rsi      # 0xb9c1
movb $0x0, %al
callq 0x3180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: pad
static void
pad (char *buf, int loc, int pos)
{
    for (; *buf; buf++) {
        if (*buf == '\t') {
            if ((loc & 3) == 0) {
                loc += 4;
            } else {
                loc += 4 - (loc & ~3);
            }
        } else {
            loc++;
        }
    }

    loc = pos / 4 - loc / 4;
    while (loc--) {
        *buf++ = '\t';
    }
    *buf = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6047
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x602e
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x6019
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x602c
movl -0xc(%rbp), %ecx
andl $-0x4, %ecx
movl $0x4, %eax
subl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x6037
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6039
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5fee
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x608e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x9, (%rax)
jmp 0x606a
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: disassemble
void
disassemble (void)
{
    int     snum;

    header ();
    for (snum = 0; snum < nsegments; snum++) {
        printf ("\n*%04o\n", segments [snum].saddr);
        disassemble_range (segments [snum].saddr, segments [snum].saddr + segments [snum].nwords);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0xceaa(%rip), %rcx      # 0x12f68
cmpl (%rcx), %eax
jge 0x612b
leaq 0xce97(%rip), %rax      # 0x12f60
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,4), %esi
leaq 0x58d9(%rip), %rdi      # 0xb9b4
movb $0x0, %al
callq 0x30a0
leaq 0xce77(%rip), %rax      # 0x12f60
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,4), %edi
leaq 0xce65(%rip), %rax      # 0x12f60
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,4), %esi
leaq 0xce53(%rip), %rax      # 0x12f60
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl 0x2(%rax,%rcx,4), %eax
addl %eax, %esi
callq 0x6380
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x60b4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/flow.c
// Function: verify_subroutines
static void
verify_subroutines (void)
{
    int     addr;
    int     page;
    int     found;

    for (addr = 0; addr < CORE_SIZE; addr++) {
        if (!(tags [addr] & TAG_SUB)) {
            continue;
        }

        // try and find returns within page
        found = 0;
        for (page = addr; page <= (addr | 00177); page++) {
            if ((core [page] & 07400) == 05400) {
                if (ea (page, core [page], NULL, NULL) == addr) {   // JMP I <start of subroutine> found!
                    tags [page] |= TAG_RETURN;  // mark the returns
                    found++;
                }
            }
        }
        if (!found) {
            tags [addr] &= ~TAG_SUB;            // not a subroutine, no return
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x1000, -0x4(%rbp)     # imm = 0x1000
jge 0x7101
movslq -0x4(%rbp), %rcx
leaq 0x9f39(%rip), %rax      # 0x10f60
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x7038
jmp 0x70f3
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
orl $0x7f, %ecx
cmpl %ecx, %eax
jg 0x70cb
movslq -0x8(%rbp), %rcx
leaq 0x7f03(%rip), %rax      # 0xef60
movswl (%rax,%rcx,2), %eax
andl $0xf00, %eax            # imm = 0xF00
cmpl $0xb00, %eax            # imm = 0xB00
jne 0x70bb
movl -0x8(%rbp), %edi
movslq -0x8(%rbp), %rcx
leaq 0x7ee5(%rip), %rax      # 0xef60
movswl (%rax,%rcx,2), %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x5c40
cmpl -0x4(%rbp), %eax
jne 0x70b9
movslq -0x8(%rbp), %rcx
leaq 0x9ec5(%rip), %rax      # 0x10f60
movzwl (%rax,%rcx,2), %eax
orl $0x8, %eax
movw %ax, %dx
leaq 0x9eb4(%rip), %rax      # 0x10f60
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x70bb
jmp 0x70bd
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7045
cmpl $0x0, -0xc(%rbp)
jne 0x70f1
movslq -0x4(%rbp), %rcx
leaq 0x9e84(%rip), %rax      # 0x10f60
movzwl (%rax,%rcx,2), %eax
andl $-0x3, %eax
movw %ax, %dx
leaq 0x9e73(%rip), %rax      # 0x10f60
movw %dx, (%rax,%rcx,2)
jmp 0x70f3
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x700f
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)