LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/scan.c
// Function: scanDataLen
static void scanDataLen(const char **iter) {
    (*iter)++; // '#'
    scanWaste(iter);
    const char *start = *iter;
    if (!isLowerCase(*start)) {
        fprintf(stderr, "Data section #keys should be lowercase; instead found unexpected character %c at line %u\n", *start, lineNumber);
    }
    for (char ch; isLowerCase(**iter); (*iter)++);
    const char *end = *iter;

    scanstackPushLabel(start, end - start, CODESIZE);
    scanstackPush(PUSH1);

    scanWaste(iter);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq (%rdi)
callq 0xd7a6
movq (%rbx), %r14
movsbl (%r14), %edx
leal -0x7b(%rdx), %ecx
movq %r14, %rax
cmpb $-0x1b, %cl
jbe 0xda2e
movq %rax, %rsi
subq %r14, %rsi
incq %rax
movb -0x1(%rax), %cl
addb $-0x7b, %cl
cmpb $-0x1b, %cl
jbe 0xd9f9
movq %rax, (%rbx)
incq %rsi
jmp 0xd9e3
pushq $0x38
popq %rdx
movq %r14, %rdi
callq 0xdb12
movzbl 0x2049421(%rip), %eax   # 0x2056e2c
leal 0x1(%rax), %ecx
movb %cl, 0x2049418(%rip)    # 0x2056e2c
leaq 0x204ec35(%rip), %rcx   # 0x205c650
movb $0x60, (%rax,%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7a6
movq 0x85c3(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
movl 0x20493ea(%rip), %ecx   # 0x2056e28
leaq 0x3964(%rip), %rsi      # 0x113a9
xorl %eax, %eax
callq 0x31d0
movq (%rbx), %rax
jmp 0xd9dd
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/scan.c
// Function: scanChar
static void scanChar(const char **iter, char expected) {
    for (char ch; (ch = **iter) != expected; (*iter)++) {
        if (ch == '\n') {
            lineNumber++;
        }
        if (!shouldIgnore(ch)) {
            fprintf(stderr, "When seeking %c found unexpected character %c at line %u", expected, ch, lineNumber);
            exit(1);
        }
    }
    (*iter)++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %r12
movl 0x20493c1(%rip), %ebx   # 0x2056e28
incq %r12
movsbl -0x1(%r12), %r15d
cmpb %bpl, %r15b
je 0xda94
cmpb $0xa, %r15b
jne 0xda83
incl %ebx
movl %ebx, 0x20493a5(%rip)   # 0x2056e28
movl %r15d, %edi
callq 0xdaca
testl %eax, %eax
je 0xdaa0
movq %r12, (%r14)
jmp 0xda67
movq %r12, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq 0x854d(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0x394e(%rip), %rsi      # 0x11403
movl %r15d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x31d0
pushq $0x1
popq %rdi
callq 0x3280
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/scan.c
// Function: shouldIgnore
static inline int shouldIgnore(char ch) {
    return ch != '('
        && ch != ')'
        && ch != ','
        && ch != ':'
        && ch != '/'
        && ch != '-'
        && ch != '{'
        && ch != '}'
        && ch != '#'
        && (ch < '0' || ch > '9')
        && (ch < 'A' || ch > 'Z')
        && (ch < 'a' || ch > 'z')
    ;
}

// Assembly:
xorl %eax, %eax
cmpl $0x3a, %edi
ja 0xdae4
movl %edi, %ecx
movabsq $0x400b30800000000, %rdx # imm = 0x400B30800000000
btq %rcx, %rdx
jae 0xdae4
retq
cmpl $0x7b, %edi
je 0xdae3
cmpl $0x7d, %edi
je 0xdae3
leal -0x3a(%rdi), %ecx
cmpb $-0xa, %cl
setae %cl
leal -0x5b(%rdi), %edx
cmpb $-0x1a, %dl
setae %dl
orb %cl, %dl
jne 0xdae3
addb $-0x7b, %dil
xorl %eax, %eax
cmpb $-0x1a, %dil
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/include/scanstack.h
// Function: scanstackPushLabel
static inline void scanstackPushLabel(const char *start, size_t len, op_t type) {
    label_t *label = (label_t *)malloc(sizeof(label_t));
    label->start = start;
    label->length = len;
    scanstackPush(type);
    labelstack[scanstackIndex] = label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %rdi
callq 0x3200
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movzbl 0x20492f7(%rip), %ecx   # 0x2056e2c
leal 0x1(%rcx), %edx
movb %dl, 0x20492ee(%rip)    # 0x2056e2c
leaq 0x204eb0b(%rip), %rsi   # 0x205c650
movb %bl, (%rcx,%rsi)
movzbl %dl, %ecx
leaq 0x204eefe(%rip), %rdx   # 0x205ca50
movq %rax, (%rdx,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/disassemble.c
// Function: labelForPc
statement_t labelForPc(pc_t pc) {
    const size_t bufLen = 8;
    char *str = calloc(bufLen, 1);
    size_t strLen = (size_t) snprintf(str, bufLen, "%u:", pc);
    /*  TODO label
    for (uint8_t i = 0; i < strLen - 1; i++) {
        str[i] += 'a' - '0';
    }
    */
    return (statement_t) {
        strLen,
        str,
        bufLen,
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x8
popq %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x31b0
movq %rax, %r12
leaq 0x38b2(%rip), %rdx      # 0x11483
movq %rax, %rdi
movq %r15, %rsi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3110
cltq
movq %rax, (%r14)
movq %r12, 0x8(%r14)
movq $0x8, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/disassemble.c
// Function: disassembleWaste
static void disassembleWaste(const char **iter) {
    while (**iter && !isHex(**iter)) {
        (*iter)++;
    }
    if (**iter == '0' && *(*iter + 1) == 'x') {
        *iter += 2;
        disassembleWaste(iter);
    }
}

// Assembly:
movq (%rdi), %rax
movb (%rax), %cl
testb %cl, %cl
je 0xdfd9
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0xdfc5
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x47, %dl
cmpb $-0x7, %dl
ja 0xdfc5
incq %rax
jmp 0xdfd4
cmpb $0x30, %cl
jne 0xdfd9
cmpb $0x78, 0x1(%rax)
jne 0xdfd9
addq $0x2, %rax
movq %rax, (%rdi)
jmp 0xdfa5
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/disassemble.c
// Function: disassembleFinalize
void disassembleFinalize() {
    for (size_t j = 0; j < jumpdests.num_pcs; j++) {
        size_t jumpdest = jumpdests.pcs[j]; 
        for (size_t i = 0; i < stack.num_statements; i++) {
            // TODO scan for label
        }
    }
    for (size_t i = 0; i < stack.num_statements; i++) {
        puts(stack.statements[i].schars);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x8
popq %rbx
xorl %r14d, %r14d
cmpq 0x2050975(%rip), %r14   # 0x205ea70
jae 0xe116
movq 0x2050974(%rip), %rax   # 0x205ea78
movq (%rax,%rbx), %rdi
callq 0x30a0
incq %r14
addq $0x18, %rbx
jmp 0xe0f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: Get5bits(unsigned char const*, int)
unsigned char Get5bits(const unsigned char *in, int i) // selects bits 5*i to 5*i+4 out of an array of bytes, bit 0 = MSB
{
	unsigned int x = in[(5*i)/8] << 8; // select byte containing bit 5*i, move to upper 8 bits of 16-bit word
	if ((5*i)%8 > (8-5)) x |= in[((5*i)/8)+1]; // bit 5*i+4 is in another byte, add to lower 8 bits of 16-bit word

	x <<= (5*i)%8; // move bit 5*i to MSB of 16-bit word
	return (x&0xFFFF) >> (16-5); // select 5 highest bits of 16-bit word
}

// Assembly:
leal (%rsi,%rsi,4), %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
movslq %eax, %rcx
movzbl (%rdi,%rcx), %eax
shll $0x8, %eax
cmpl $0x4, %edx
jl 0x2d2b
movzbl 0x1(%rdi,%rcx), %ecx
orl %ecx, %eax
shlxl %edx, %eax, %eax
shrl $0xb, %eax
andb $0x1f, %al
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: Get8bits(unsigned char const*, int)
unsigned char Get8bits(const unsigned char *in, int i) // selects bits 8*i to 8*i+7 out of an array of 5-bit elements, bit 0 = MSB
{
	unsigned int x = in[(8*i)/5] << 10; // select element containing bit 8*i, move to upper 5 bits of 15-bit word
	x |= (((in[((8*i)/5)+1]) & 0x3FF) << 5); // bit 8*i+7 is definitely in another element, add to middle 5 bits of 15-bit word
	if ((8*i)%5 > (10-8)) x |= ((in[((8*i)/5)+2]) & 0x3FF); // bit 8*i+7 is in yet another element, add to lower 5 bits of 10-bit word
	x <<= (8*i)%5; // move bit 8*i to MSB of 15-bit word
	return (x&0x7FFF) >> (15-8); // select 8 highest bits of 15-bit word
}

// Assembly:
leal (,%rsi,8), %eax
pushq $0x5
popq %rcx
cltd
idivl %ecx
movslq %eax, %rcx
movzbl (%rdi,%rcx), %esi
shll $0xa, %esi
movzbl 0x1(%rdi,%rcx), %eax
shll $0x5, %eax
orl %esi, %eax
cmpl $0x3, %edx
jl 0x2d63
movzbl 0x2(%rdi,%rcx), %ecx
orl %ecx, %eax
shlxl %edx, %eax, %eax
shrl $0x7, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: PrintElementsStateHex(unsigned char*)
void PrintElementsStateHex(unsigned char *state) //prints the state in hexadecimal format element by element starting from a_{0,0} and row by row
{
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++)
			printf(" %.2x", state[NumberColumns*j+i]);
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %rbp
leaq 0x11f9(%rip), %r14      # 0x4000
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x2e3d
xorl %r12d, %r12d
cmpq $0x8, %r12
je 0x2e2d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
incq %r12
jmp 0x2e13
movl %ebp, %edi
callq 0x2070
incq %r15
addq $0x8, %rbx
jmp 0x2e0a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: PrintElementsStateDec(unsigned char*)
void PrintElementsStateDec(unsigned char *state) //prints the state in decimal format element by element starting from a_{0,0} and row by row
{
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++)
			printf(" %d", state[NumberColumns*j+i]);
		printf("\n");
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %rbp
leaq 0x11ab(%rip), %r14      # 0x4006
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x2e91
xorl %r12d, %r12d
cmpq $0x8, %r12
je 0x2e81
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
incq %r12
jmp 0x2e67
movl %ebp, %edi
callq 0x2070
incq %r15
addq $0x8, %rbx
jmp 0x2e5e
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: ShiftRows(unsigned char*)
void ShiftRows(unsigned char *state) //ShiftRows operation on the state
{
	unsigned char tmp[StateSize];
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++){
			tmp[NumberColumns*j+i]=state[NumberColumns*j+((i+shiftconst[j])%NumberColumns)];
		}
	}
	for(int j=0; j<StateSize; j++)
		state[j]=tmp[j];
}

// Assembly:
pushq %rbx
leaq -0x30(%rsp), %rcx
xorl %esi, %esi
movq 0x3012(%rip), %r8       # 0x5fe8
movl $0x8, %r9d
cmpq $0x5, %rsi
je 0x3018
movl (%r8,%rsi,4), %r10d
leal (,%rsi,8), %r11d
xorl %ebx, %ebx
cmpq $0x8, %rbx
je 0x300f
leal (%r10,%rbx), %eax
cltd
idivl %r9d
addl %r11d, %edx
movslq %edx, %rax
movb (%rdi,%rax), %al
movb %al, (%rcx,%rbx)
incq %rbx
jmp 0x2ff0
incq %rsi
addq $0x8, %rcx
jmp 0x2fdc
xorl %eax, %eax
cmpq $0x28, %rax
je 0x302c
movb -0x30(%rsp,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x301a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: ShiftRowsInv(unsigned char*)
void ShiftRowsInv(unsigned char *state) //Inverse ShiftRows operation on the state
{
	unsigned char tmp[StateSize];
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++){
			tmp[NumberColumns*j+i]=state[NumberColumns*j+((i-shiftconst[j]+NumberColumns)%NumberColumns)];
		}
	}
	for(int j=0; j<StateSize; j++)
		state[j]=tmp[j];
}

// Assembly:
pushq %rbx
leaq -0x30(%rsp), %rcx
xorl %esi, %esi
movq 0x2fab(%rip), %r8       # 0x5fe8
movl $0x8, %r9d
cmpq $0x5, %rsi
je 0x3083
movl (%r8,%rsi,4), %r10d
leal (,%rsi,8), %r11d
xorl %ebx, %ebx
cmpq $0x8, %rbx
je 0x307a
movl %ebx, %eax
orl $0x8, %eax
subl %r10d, %eax
cltd
idivl %r9d
addl %r11d, %edx
movslq %edx, %rax
movb (%rdi,%rax), %al
movb %al, (%rcx,%rbx)
incq %rbx
jmp 0x3057
incq %rsi
addq $0x8, %rcx
jmp 0x3043
xorl %eax, %eax
cmpq $0x28, %rax
je 0x3097
movb -0x30(%rsp,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x3085
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: MixColumns(unsigned char*)
void MixColumns(unsigned char *state) //MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			for(int j=0; j<(NumberRows-1); j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j+1)+i];
			tmp[NumberColumns*4+i]=state[i]^T18(state[NumberColumns*1+i])^T2(state[NumberColumns*2+i])^T2(state[NumberColumns*3+i])^T18(state[NumberColumns*4+i]);
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
movq 0x18(%rsp), %r14
cmpl $0x5, %eax
je 0x3207
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %r13
leaq 0x30(%rsp), %r12
xorl %edx, %edx
xorl %eax, %eax
cmpq $0x8, %rdx
jne 0x314c
jmp 0x31f5
movb (%r13,%rax,8), %cl
movb %cl, (%r12,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x3140
movb (%r14,%rdx), %al
movb %al, 0x7(%rsp)
movzbl 0x8(%r14,%rdx), %edi
movq %rdx, 0x8(%rsp)
callq 0x2180
movl %eax, %ebp
movq 0x8(%rsp), %rax
movb 0x10(%r14,%rax), %bl
movq 0x8(%rsp), %rax
movb 0x18(%r14,%rax), %r15b
leal (%rbx,%rbx), %eax
andb $0x1e, %al
movl %eax, 0x14(%rsp)
shlb $0x3, %bl
sarb $0x7, %bl
andb $0x5, %bl
leal (%r15,%r15), %eax
andb $0x1e, %al
movl %eax, 0x10(%rsp)
shlb $0x3, %r15b
sarb $0x7, %r15b
andb $0x5, %r15b
movq 0x8(%rsp), %rax
movzbl 0x20(%r14,%rax), %edi
callq 0x2180
movq 0x8(%rsp), %rdx
xorb 0x7(%rsp), %bpl
xorb 0x14(%rsp), %bpl
xorb %bl, %bpl
xorb 0x10(%rsp), %al
xorb %r15b, %al
xorb %bpl, %al
movb %al, 0x50(%rsp,%rdx)
incq %rdx
incq %r12
incq %r13
jmp 0x3133
movb 0x30(%rsp,%rax), %cl
movq 0x18(%rsp), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq $0x28, %rax
jne 0x31e6
movq 0x28(%rsp), %rax
incl %eax
jmp 0x3119
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: MixColumnsInv(unsigned char*)
void MixColumnsInv(unsigned char *state) //Inverse MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			tmp[i]=T18(state[i])^T2(state[NumberColumns*1+i])^T2(state[NumberColumns*2+i])^T18(state[NumberColumns*3+i])^state[NumberColumns*4+i];
 			for(int j=1; j<NumberRows; j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j-1)+i];
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
xorl %eax, %eax
cmpl $0x5, %eax
je 0x330d
movq %rax, 0x18(%rsp)
movq %r15, %r12
leaq 0x28(%rsp), %r13
xorl %edx, %edx
cmpq $0x8, %rdx
je 0x32ec
movzbl (%r15,%rdx), %edi
movq %rdx, 0x8(%rsp)
callq 0x2180
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rax
movb 0x8(%r15,%rax), %bl
movq 0x8(%rsp), %rax
movb 0x10(%r15,%rax), %r14b
leal (%rbx,%rbx), %ebp
andb $0x1e, %bpl
shlb $0x3, %bl
sarb $0x7, %bl
andb $0x5, %bl
leal (%r14,%r14), %eax
andb $0x1e, %al
movl %eax, 0x14(%rsp)
shlb $0x3, %r14b
sarb $0x7, %r14b
andb $0x5, %r14b
movq 0x8(%rsp), %rax
movzbl 0x18(%r15,%rax), %edi
callq 0x2180
movq 0x8(%rsp), %rdx
xorb 0x7(%rsp), %bpl
xorb %bl, %bpl
xorb 0x14(%rsp), %al
xorb %r14b, %al
xorb %bpl, %al
xorb 0x20(%r15,%rdx), %al
movb %al, 0x20(%rsp,%rdx)
xorl %eax, %eax
cmpq $0x4, %rax
je 0x32de
movb (%r12,%rax,8), %cl
movb %cl, (%r13,%rax,8)
incq %rax
jmp 0x32ca
incq %rdx
incq %r13
incq %r12
jmp 0x3241
xorl %eax, %eax
cmpq $0x28, %rax
je 0x3301
movb 0x20(%rsp,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0x32ee
movq 0x18(%rsp), %rax
incl %eax
jmp 0x3229
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: GenerateRoundConstants()
void GenerateRoundConstants() //Generation of 5-bit round constant by using the primitive polynomial x^5+x^2+1 with initial value 1.
{
	//Round constants for p_1
	rc_p1[0]=1;
	//printf("\nRound constants for p_1: \n %.2x", rc_p1[0]);
	for(int i=1; i<p1rounds; i++){
		rc_p1[i] = ((rc_p1[i-1]<<1) ^ ((rc_p1[i-1]>>1)&1) ^ ((rc_p1[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p1[i]);
	}
}

// Assembly:
movq 0x2c71(%rip), %rax      # 0x5fc8
movb $0x1, (%rax)
pushq $0x1
popq %rcx
movb $0x1, %dl
cmpq $0xc, %rcx
je 0x338c
leal (%rdx,%rdx), %esi
movl %edx, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %dl
andb $0x1, %dl
andb $0x1e, %sil
orb %dil, %sil
xorb %dl, %sil
movb %sil, (%rax,%rcx)
incq %rcx
movl %esi, %edx
jmp 0x335f
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: InitializeState(unsigned char*, unsigned char*)
void InitializeState(unsigned char *state, unsigned char *key)
{
	GenerateRoundConstants();

	for(int i=0; i<RateSizeElements; i++)
		state[i]=0;
	for(int i=0; i<KeySizeElements; i++)
		state[RateSizeElements+i]=key[i];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2160
xorl %eax, %eax
cmpq $0x8, %rax
je 0x33ae
movb $0x0, (%r14,%rax)
incq %rax
jmp 0x339e
xorl %eax, %eax
cmpq $0x20, %rax
je 0x33c3
movb (%rbx,%rax), %cl
movb %cl, 0x8(%r14,%rax)
incq %rax
jmp 0x33b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: p_1(unsigned char*)
void p_1(unsigned char *state)
{
	for(int rnd=0; rnd<p1rounds; rnd++)
	{
		primate(state);	
		state[RateSizeElements+1]^=rc_p1[rnd];		
		//printf("\nState after AddConstant:\n\n\n"); PrintElementsStateDec(state);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2beb(%rip), %r15      # 0x5fc8
cmpq $0xc, %r14
je 0x33f7
movq %rbx, %rdi
callq 0x2150
movb (%r15,%r14), %al
xorb %al, 0x9(%rbx)
incq %r14
jmp 0x33dd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: p_1_inv(unsigned char*)
void p_1_inv(unsigned char *state)
{
	for(int rnd=0; rnd<p1rounds; rnd++)
	{
		state[RateSizeElements+1]^=rc_p1[p1rounds-rnd-1];		
		//printf("\nState after AddConstant:\n\n\n"); PrintElementsStateDec(state);
		primateInv(state);	
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0xc
popq %rax
movq 0x2bb9(%rip), %r14      # 0x5fc8
movq %rax, %r15
subq $0x1, %r15
jb 0x342d
movb -0x1(%r14,%rax), %al
xorb %al, 0x9(%rbx)
movq %rbx, %rdi
callq 0x21b0
movq %r15, %rax
jmp 0x3412
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: dlo
V dlo(O o){
    switch(o->t){
    case TS:case TCB:DL(o->s.s);BK;
    case TA:while(len(o->a))dlo(pop(o->a));dls(o->a);BK;
    case TD:BK;
    case TR:dlo(o->e.k);dlo(o->e.v);BK;
    }if(!rcy(&ofl,o))DL(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2cb9
leaq 0x53a4(%rip), %rcx      # 0x8018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
callq 0x2030
jmp 0x2cb9
callq 0x26d3
movq %rax, %rdi
callq 0x2c5b
movq 0x8(%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
jne 0x2c88
callq 0x27be
jmp 0x2cb9
movq 0x8(%rbx), %rdi
callq 0x2c5b
movq 0x10(%rbx), %rdi
callq 0x2c5b
leaq 0x9b60(%rip), %rdi      # 0xc820
movq %rbx, %rsi
callq 0x2444
testl %eax, %eax
je 0x2cd3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: dup
O dup(O o){
    L z;S s;switch(o->t){
    case TCB:R newocb(o->s.s,o->s.z);BK;
    case TS:R newos(o->s.s,o->s.z);BK;
    case TD:R newod(o->d);BK;
    case TA:R dupa(o);BK;
    case TR:R newoe(dup(o->e.k),dup(o->e.v));BK;
    }R 0; //appease the compiler
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x2ddd
movq %rdi, %rbx
leaq 0x52b4(%rip), %rcx      # 0x8028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x8(%rbx), %xmm0
popq %rbx
popq %r14
popq %rbp
jmp 0x2aa2
movq 0x8(%rbx), %rdi
callq 0x2d5b
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x2d5b
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2c36
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2d0b
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2ac7
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2b3e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: eqo
I eqo(O a,O b){
    if(a->t!=b->t)R 0;
    switch(a->t){
    case TS:case TCB:R a->s.z!=b->s.z?0:memcmp(a->s.s,b->s.s,a->s.z)==0;
    case TD:R a->d==b->d;
    case TR:R eqo(a->e.k,b->e.k)&&eqo(a->e.v,b->e.v);
    default:ex("non-TS-TD in eqo");R 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5227(%rip), %r15      # 0x803c
movl (%rbx), %eax
cmpl (%r14), %eax
jne 0x2e65
cmpl $0x4, %eax
ja 0x2e8b
movl %eax, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2dfe
testl %eax, %eax
je 0x2e65
movq 0x10(%rbx), %rbx
movq 0x10(%r14), %r14
jmp 0x2e15
movq 0x10(%rbx), %rdx
cmpq 0x10(%r14), %rdx
jne 0x2e65
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x21c0
testl %eax, %eax
sete %al
jmp 0x2e7d
xorl %eax, %eax
jmp 0x2e7d
movsd 0x8(%r14), %xmm0
cmpeqsd 0x8(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54dd(%rip), %rdi      # 0x836f
callq 0x23a8
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: truth
I truth(O o){
    switch(o->t){
    case TD:R o->d!=0;BK;
    case TS:R o->s.z!=0;BK;
    case TA:R len(o->a)!=0;BK;
    case TCB:{O t;I r;excb(o);t=pop(top(rst));r=truth(t);dlo(t);R r;}
    case TR:R truth(o->e.k)&&truth(o->e.v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x2f3f
movq %rdi, %rbx
leaq 0x519c(%rip), %rcx      # 0x8050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorpd %xmm0, %xmm0
cmpneqsd 0x8(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x2f43
movq 0x8(%rbx), %rdi
callq 0x2e97
testl %eax, %eax
je 0x2f41
movq 0x10(%rbx), %rdi
callq 0x2e97
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jmp 0x2f3a
movq 0x8(%rbx), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
jmp 0x2f3a
movq %rbx, %rdi
callq 0x2f48
movq 0x990d(%rip), %rdi      # 0xc818
callq 0x26fd
movq %rax, %rdi
callq 0x26d3
movq %rax, %rbx
movq %rax, %rdi
callq 0x2e97
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2c5b
movl %r14d, %eax
jmp 0x2f43
xorl %eax, %eax
cmpq $0x0, 0x10(%rbx)
setne %al
jmp 0x2f43
jmp 0x2f43
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: eq
V eq(ST s){O a,b;b=pop(s);a=pop(s);
    if(b->t==TA){I i,w=0;if(a->t!=TR)a=newoe(a,pop(s));for(i=0;i<len(b->a);++i){O e=b->a->st[i];if(e->t!=TR)TE;if(eqo(e->e.k,a->e.k)){dlo(e);b->a->st[i]=a;w=1;BK;}}if(!w)psh(b->a,a);psh(s,b);} //set
    else if(a->t!=TA){psh(s,newod(eqo(a,b)));dlo(a);dlo(b);} //equal
    else TE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x26d3
movq %rax, %rbx
movq %r14, %rdi
callq 0x26d3
movq %rax, %r15
cmpl $0x2, (%rbx)
movl (%rax), %eax
jne 0x3b12
cmpl $0x4, %eax
je 0x3ac8
movq %r14, %rdi
callq 0x26d3
movq %r15, %rdi
movq %rax, %rsi
callq 0x2c36
movq %rax, %r15
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
cmpq %r13, 0x8(%rdi)
jbe 0x3b54
movq (%rdi), %rax
movq (%rax,%r13,8), %r12
cmpl $0x4, (%r12)
jne 0x3b75
movq 0x8(%r12), %rdi
movq 0x8(%r15), %rsi
callq 0x2dfe
incq %r13
testl %eax, %eax
je 0x3acb
movq %r12, %rdi
callq 0x2c5b
movq 0x8(%rbx), %rax
movq (%rax), %rax
movq %r15, -0x8(%rax,%r13,8)
jmp 0x3b5c
cmpl $0x2, %eax
je 0x3b75
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2dfe
cvtsi2sd %eax, %xmm0
callq 0x2aa2
movq %r14, %rdi
movq %rax, %rsi
callq 0x26a9
movq %r15, %rdi
callq 0x2c5b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c5b
movq %r15, %rsi
callq 0x26a9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26a9
leaq 0x4804(%rip), %rdi      # 0x8380
callq 0x23a8
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: fdo
V fdo(ST s){
    I d;O b=pop(s);O n=pop(s);if(b->t!=TCB)TE;
    if(n->t==TD){O on=v['n'];for(d=0;d<n->d;++d){v['n']=newod(d);excb(b);dlo(v['n']);}dlo(n);dlo(b);v['n']=on;} //for loop
    else if(n->t==TA||n->t==TS){I ts;O on=v['n'];ts=n->t==TS;for(d=0;d<(ts?n->s.z:len(n->a));++d){v['n']=ts?newosc(n->s.s[d]):n->a->st[d];excb(b);if(ts)dlo(v['n']);}v['n']=on;dlo(n);dlo(b);} //for each
    else TE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x26d3
movq %rax, %rbx
movq %r14, %rdi
callq 0x26d3
cmpl $0x3, (%rbx)
jne 0x513f
movq %rax, %r14
movl (%rax), %r15d
leal -0x1(%r15), %eax
cmpl $0x2, %eax
jae 0x50d4
movq 0x7b57(%rip), %r12      # 0xcbb0
xorl %r13d, %r13d
cmpl $0x1, %r15d
jne 0x5078
cmpq %r13, 0x10(%r14)
jbe 0x50af
movq 0x8(%r14), %rax
movsbl (%rax,%r13), %edi
callq 0x2bd4
jmp 0x5089
movq 0x8(%r14), %rax
cmpq %r13, 0x8(%rax)
jbe 0x50af
movq (%rax), %rax
movq (%rax,%r13,8), %rax
movq %rax, 0x7b20(%rip)      # 0xcbb0
movq %rbx, %rdi
callq 0x2f48
cmpl $0x1, %r15d
jne 0x50aa
movq 0x7b0b(%rip), %rdi      # 0xcbb0
callq 0x2c5b
incq %r13
jmp 0x505c
movq %r12, 0x7afa(%rip)      # 0xcbb0
movq %r14, %rdi
callq 0x2c5b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c5b
testl %r15d, %r15d
jne 0x513f
xorl %r12d, %r12d
movq 0x7acd(%rip), %r15      # 0xcbb0
cvtsi2sd %r12d, %xmm0
movsd 0x8(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5119
callq 0x2aa2
movq %rax, 0x7ab0(%rip)      # 0xcbb0
movq %rbx, %rdi
callq 0x2f48
movq 0x7aa1(%rip), %rdi      # 0xcbb0
callq 0x2c5b
incl %r12d
jmp 0x50e3
movq %r14, %rdi
callq 0x2c5b
movq %rbx, %rdi
callq 0x2c5b
movq %r15, 0x7a80(%rip)      # 0xcbb0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x323a(%rip), %rdi      # 0x8380
callq 0x23a8
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: toca
V toca(ST st,O o){
    if(o->t==TS){ST ca=newst();I p=0;for(;p<o->s.z;++p)psh(ca,newosc(o->s.s[p]));psh(st,newoa(ca));dlo(o);}
    else if(o->t==TA){msrt(dfsrt,0,st,o->a);psh(st,o);}
    else if(o->t==TCB){O a=pop(st);if(a->t!=TA)TE;msrt(cbsrt,o,st,a->a);psh(st,a);}
    else TE;}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x3, %eax
je 0x549e
cmpl $0x2, %eax
je 0x5481
cmpl $0x1, %eax
jne 0x54fa
xorl %r12d, %r12d
callq 0x2620
movq %rax, %r15
cmpq %r12, 0x10(%rbx)
jbe 0x54d7
movq 0x8(%rbx), %rax
movsbl (%rax,%r12), %edi
callq 0x2bd4
movq %r15, %rdi
movq %rax, %rsi
callq 0x26a9
incq %r12
jmp 0x545d
movq 0x8(%rbx), %rcx
leaq -0x15e(%rip), %rdi      # 0x532e
xorl %esi, %esi
movq %r14, %rdx
callq 0x535a
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x54ca
movq %r14, %rdi
callq 0x26d3
cmpl $0x2, (%rax)
jne 0x54fa
movq %rax, %r15
movq 0x8(%rax), %rcx
leaq -0x169(%rip), %rdi      # 0x5350
movq %rbx, %rsi
movq %r14, %rdx
callq 0x535a
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x26a9
movq %r15, %rdi
callq 0x2c17
movq %r14, %rdi
movq %rax, %rsi
callq 0x26a9
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2c5b
leaq 0x2e7f(%rip), %rdi      # 0x8380
callq 0x23a8
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: dumpo
V dumpo(O o,I n){
    L i;I m=n*2;while(m-->0)putchar(' ');
    switch(o->t){
    case TD:printf("%f\n",o->d);BK;
    case TS:putchar('"');for(i=0;i<o->s.z;i++){C c=o->s.s[i];if(c>=ECOFF&&c<(ECOFF+sizeof(ecm)))printf("\\%c",ecm[c-ECOFF]);else putchar(c);}puts("\"");BK;
    case TA:puts("[]");for(i=0;i<len(o->a);++i)dumpo(o->a->st[i],n+1);BK;
    case TCB:printf("{%s}\n",o->s.s);BK;
    case TR:puts(":");dumpo(o->e.k,n+1);dumpo(o->e.v,n+1);BK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x20
popq %r15
leaq 0x2a6e(%rip), %r13      # 0x82c8
leal (%r14,%r14), %r12d
testl %r12d, %r12d
jle 0x5870
decl %r12d
movl %r15d, %edi
callq 0x2040
jmp 0x585e
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x58d3
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
leaq 0x2b89(%rip), %rdi      # 0x8412
callq 0x2080
movq 0x8(%rbx), %rdi
incl %r14d
movl %r14d, %esi
callq 0x583b
movq 0x10(%rbx), %rbx
jmp 0x585a
leaq 0x2b5f(%rip), %rdi      # 0x8409
callq 0x2080
incl %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
cmpq 0x8(%rax), %r15
jae 0x58d3
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movl %r14d, %esi
callq 0x583b
incq %r15
jmp 0x58b5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x22
popq %rdi
callq 0x2040
leaq 0x6a03(%rip), %r15      # 0xc2f4
leaq 0x2b0b(%rip), %r14      # 0x8403
xorl %r12d, %r12d
cmpq 0x10(%rbx), %r12
jae 0x592f
movq 0x8(%rbx), %rax
movsbl (%rax,%r12), %edi
leal -0x7(%rdi), %eax
cmpb $0x6, %al
ja 0x5925
addl $-0x7, %edi
movsbl (%rdi,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
jmp 0x592a
callq 0x2040
incq %r12
jmp 0x58fb
leaq 0x2ad1(%rip), %rdi      # 0x8407
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
movsd 0x8(%rbx), %xmm0
leaq 0x2aaa(%rip), %rdi      # 0x83ff
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
movq 0x8(%rbx), %rsi
leaq 0x2a97(%rip), %rdi      # 0x840c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/o.c
// Function: repl
V repl(){ //repl
    C b[BZ];isrepl=1;printf("O REPL");for(;;){
        printf("\n>>> ");if(!fgets(b,BZ,stdin))BK; //get line
        if(!setjmp(jb))excs(b,0); //run line
    }excs("",1); //cleanup
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movl $0x1, 0x6824(%rip)      # 0xc310
leaq 0x297c(%rip), %rdi      # 0x846f
xorl %eax, %eax
movl %eax, %r14d
callq 0x2100
movq 0x648c(%rip), %r15      # 0xbf90
leaq -0x830(%rbp), %r12
movl $0x800, %r13d           # imm = 0x800
leaq 0x6c08(%rip), %rbx      # 0xc720
leaq 0x2957(%rip), %rdi      # 0x8476
movl %r14d, %eax
callq 0x2100
movq (%r15), %rdx
movq %r12, %rdi
movl %r13d, %esi
callq 0x2150
testq %rax, %rax
je 0x5b52
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x5b18
movq %r12, %rdi
xorl %esi, %esi
callq 0x59da
jmp 0x5b18
leaq 0x28a9(%rip), %rdi      # 0x8402
pushq $0x1
popq %rsi
callq 0x59da
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regaux.c
// Function: renewmatch
extern void
_renewmatch(Resub *mp, int ms, Resublist *sp)
{
	int i;

	if(mp==0 || ms<=0)
		return;
	if(mp[0].s.sp==0 || sp->m[0].s.sp<mp[0].s.sp ||
	   (sp->m[0].s.sp==mp[0].s.sp && sp->m[0].e.ep>mp[0].e.ep)){
		for(i=0; i<ms && i<NSUBEXP; i++)
			mp[i] = sp->m[i];
		for(; i<ms; i++)
			mp[i].s.sp = mp[i].e.ep = 0;
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x5d5a
movq (%rdi), %rax
testq %rax, %rax
je 0x5d10
cmpq %rax, (%rdx)
jae 0x5d58
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
cmpq $0x20, %rax
movabsq $0x20, %rsi
cmovbq %rax, %rsi
xorl %ecx, %ecx
cmpq %rsi, %rcx
jae 0x5d42
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
incq %rcx
addq $0x10, %rdi
addq $0x10, %rdx
jmp 0x5d2a
xorps %xmm0, %xmm0
cmpq %rax, %rcx
jae 0x5d56
incq %rcx
movups %xmm0, (%rdi)
addq $0x10, %rdi
jmp 0x5d45
popq %rbp
retq
je 0x5d5b
retq
movq 0x8(%rdx), %rax
cmpq 0x8(%rdi), %rax
ja 0x5d10
jmp 0x5d5a
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regaux.c
// Function: renewthread
extern Relist*
_renewthread(Relist *lp,	/* _relist to add to */
	Reinst *ip,		/* instruction to add */
	int ms,
	Resublist *sep)		/* pointers to subexpressions */
{
	Relist *p;

	for(p=lp; p->inst; p++){
		if(p->inst == ip){
			if(sep->m[0].s.sp < p->se.m[0].s.sp){
				if(ms > 1)
					p->se = *sep;
				else
					p->se.m[0] = sep->m[0];
			}
			return 0;
		}
	}
	p->inst = ip;
	if(ms > 1)
		p->se = *sep;
	else
		p->se.m[0] = sep->m[0];
	(++p)->inst = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x208, %rbx            # imm = 0x208
movq -0x208(%rbx), %rax
testq %rax, %rax
je 0x5db2
cmpq %rsi, %rax
jne 0x5d70
movq (%rcx), %rax
cmpq -0x200(%rbx), %rax
jae 0x5de6
addq $-0x200, %rbx           # imm = 0xFE00
cmpl $0x2, %edx
jl 0x5de0
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x21a0
jmp 0x5de6
movq %rsi, -0x208(%rbx)
leaq -0x200(%rbx), %rdi
cmpl $0x2, %edx
jl 0x5dd4
movl $0x200, %edx            # imm = 0x200
movq %rcx, %rsi
callq 0x21a0
jmp 0x5dda
movups (%rcx), %xmm0
movups %xmm0, (%rdi)
andq $0x0, (%rbx)
jmp 0x5de8
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regaux.c
// Function: renewemptythread
extern Relist*
_renewemptythread(Relist *lp,	/* _relist to add to */
	Reinst *ip,		/* instruction to add */
	int ms,
	char *sp)		/* pointers to subexpressions */
{
	Relist *p;

	for(p=lp; p->inst; p++){
		if(p->inst == ip){
			if(sp < p->se.m[0].s.sp) {
				if(ms > 1)
					memset(&p->se, 0, sizeof(p->se));
				p->se.m[0].s.sp = sp;
			}
			return 0;
		}
	}
	p->inst = ip;
	if(ms > 1)
		memset(&p->se, 0, sizeof(p->se));
	p->se.m[0].s.sp = sp;
	(++p)->inst = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
addq $0x208, %rbx            # imm = 0x208
movq -0x208(%rbx), %rax
testq %rax, %rax
je 0x5e42
cmpq %rsi, %rax
jne 0x5dff
cmpq %r14, -0x200(%rbx)
jbe 0x5e3e
addq $-0x200, %rbx           # imm = 0xFE00
cmpl $0x2, %edx
jl 0x5e3b
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2120
movq %r14, (%rbx)
xorl %ebx, %ebx
jmp 0x5e6c
movq %rsi, -0x208(%rbx)
cmpl $0x2, %edx
jl 0x5e61
leaq -0x200(%rbx), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x2120
movq %r14, -0x200(%rbx)
andq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regaux.c
// Function: rrenewemptythread
extern Relist*
_rrenewemptythread(Relist *lp,	/* _relist to add to */
	Reinst *ip,		/* instruction to add */
	int ms,
	Rune *rsp)		/* pointers to subexpressions */
{
	Relist *p;

	for(p=lp; p->inst; p++){
		if(p->inst == ip){
			if(rsp < p->se.m[0].s.rsp) {
				if(ms > 1)
					memset(&p->se, 0, sizeof(p->se));
				p->se.m[0].s.rsp = rsp;
			}
			return 0;
		}
	}
	p->inst = ip;
	if(ms > 1)
		memset(&p->se, 0, sizeof(p->se));
	p->se.m[0].s.rsp = rsp;
	(++p)->inst = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
addq $0x208, %rbx            # imm = 0x208
movq -0x208(%rbx), %rax
testq %rax, %rax
je 0x5ec4
cmpq %rsi, %rax
jne 0x5e81
cmpq %r14, -0x200(%rbx)
jbe 0x5ec0
addq $-0x200, %rbx           # imm = 0xFE00
cmpl $0x2, %edx
jl 0x5ebd
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2120
movq %r14, (%rbx)
xorl %ebx, %ebx
jmp 0x5eee
movq %rsi, -0x208(%rbx)
cmpl $0x2, %edx
jl 0x5ee3
leaq -0x200(%rbx), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x2120
movq %r14, -0x200(%rbx)
andq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regcomp.c
// Function: pushator
static	void
pushator(int t)
{
	if(atorp >= &atorstack[NSTACK])
		cant("operator stack overflow");
	*atorp++ = t;
	*subidp++ = cursubid;
}

// Assembly:
movq 0x6db6(%rip), %rax      # 0xd1e0
leaq 0x6daf(%rip), %rcx      # 0xd1e0
cmpq %rcx, %rax
jae 0x645e
leaq 0x4(%rax), %rcx
movq %rcx, 0x6d9f(%rip)      # 0xd1e0
movl %edi, (%rax)
movl 0x6f53(%rip), %eax      # 0xd39c
movq 0x6f40(%rip), %rcx      # 0xd390
leaq 0x4(%rcx), %rdx
movq %rdx, 0x6f35(%rip)      # 0xd390
movl %eax, (%rcx)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x210a(%rip), %rdi      # 0x8573
callq 0x6836
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regcomp.c
// Function: operator
static	void
operator(int t)
{
	if(t==RBRA && --nbra<0)
		rcerror("unmatched right paren");
	if(t==LBRA){
		if(++cursubid >= NSUBEXP)
			rcerror ("too many subexpressions");
		nbra++;
		if(lastwasand)
			operator(CAT);
	} else
		evaluntil(t);
	if(t != RBRA)
		pushator(t);
	lastwasand = FALSE;
	if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
		lastwasand = TRUE;	/* these look like operands */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x81, %edi
jne 0x649d
movl 0x6d08(%rip), %eax      # 0xd18c
leal -0x1(%rax), %ecx
movl %ecx, 0x6cff(%rip)      # 0xd18c
testl %eax, %eax
jg 0x64d4
leaq 0x216b(%rip), %rdi      # 0x8603
callq 0x6818
cmpl $0x82, %ebx
jne 0x64d4
movl 0x6ef1(%rip), %eax      # 0xd39c
leal 0x1(%rax), %ecx
movl %ecx, 0x6ee8(%rip)      # 0xd39c
cmpl $0x1f, %eax
jge 0x651b
incl 0x6ccd(%rip)            # 0xd18c
cmpb $0x1, 0x6ed2(%rip)      # 0xd398
jne 0x64e3
movl $0x84, %edi
callq 0x646e
jmp 0x64e3
movl %ebx, %edi
callq 0x659b
cmpl $0x81, %ebx
je 0x64ea
movl %ebx, %edi
callq 0x6423
cmpl $0x81, %ebx
sete %al
movl %ebx, %ecx
andl $-0x3, %ecx
cmpl $0x85, %ecx
sete %cl
cmpl $0x86, %ebx
sete %dl
orb %al, %dl
orb %cl, %dl
movb %dl, 0x6e84(%rip)       # 0xd398
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x20f7(%rip), %rdi      # 0x8619
callq 0x6818
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regcomp.c
// Function: operand
static	void
operand(int t)
{
	Reinst *i;

	if(lastwasand)
		operator(CAT);	/* catenate is implicit */
	i = newinst(t);

	if(t == CCLASS || t == NCCLASS)
		i->r.cp = yyclassp;
	if(t == RUNE)
		i->r.r = yyrune;

	pushand(i, i);
	lastwasand = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpb $0x1, 0x6e62(%rip)      # 0xd398
jne 0x6542
movl $0x84, %edi
callq 0x646e
movq 0x6b47(%rip), %rdi      # 0xd090
movl %ebx, (%rdi)
leaq 0x8(%rdi), %rax
leaq 0x18(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rcx, 0x6b2f(%rip)      # 0xd090
leal -0xc5(%rbx), %ecx
cmpl $0x1, %ecx
ja 0x6578
movq 0x6e35(%rip), %rcx      # 0xd3a8
movq %rcx, (%rax)
jmp 0x6585
cmpl $0x7f, %ebx
jne 0x6585
movl 0x6e1d(%rip), %ecx      # 0xd3a0
movl %ecx, (%rax)
movq %rdi, %rsi
callq 0x68d8
movb $0x1, 0x6e04(%rip)      # 0xd398
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regcomp.c
// Function: nextc
static	int
nextc(Rune *rp)
{
	if(lexdone){
		*rp = 0;
		return 1;
	}
	exprp += chartorune(rp, exprp);
	if(*rp == '\\'){
		exprp += chartorune(rp, exprp);
		return 1;
	}
	if(*rp == 0)
		lexdone = 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x68f8(%rip)      # 0xd178
jne 0x6887
andl $0x0, (%rbx)
jmp 0x68c5
movq 0x68f2(%rip), %rsi      # 0xd180
movq %rbx, %rdi
callq 0x7428
movslq %eax, %rsi
addq 0x68e0(%rip), %rsi      # 0xd180
movq %rsi, 0x68d9(%rip)      # 0xd180
movl (%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x68cf
cmpl $0x5c, %ecx
jne 0x68c8
movq %rbx, %rdi
callq 0x7428
cltq
addq %rax, 0x68bb(%rip)      # 0xd180
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, 0x68a2(%rip)      # 0xd178
jmp 0x68c8
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regcomp.c
// Function: pushand
static	void
pushand(Reinst *f, Reinst *l)
{
	if(andp >= &andstack[NSTACK])
		cant("operand stack overflow");
	andp->first = f;
	andp->last = l;
	andp++;
}

// Assembly:
movq 0x6a51(%rip), %rax      # 0xd330
leaq 0x6a4a(%rip), %rcx      # 0xd330
cmpq %rcx, %rax
jae 0x68fe
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x6a33(%rip)      # 0xd330
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d28(%rip), %rdi      # 0x8631
callq 0x6836
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regcomp.c
// Function: popand
static	Node*
popand(int op)
{
	Reinst *inst;

	if(andp <= &andstack[0]){
		regerr2("missing operand for ", op);
		inst = newinst(NOP);
		pushand(inst,inst);
	}
	return --andp;
}

// Assembly:
movq 0x6a1b(%rip), %rax      # 0xd330
leaq 0x68d4(%rip), %rcx      # 0xd1f0
cmpq %rcx, %rax
jbe 0x692d
addq $-0x10, %rax
movq %rax, 0x6a04(%rip)      # 0xd330
retq
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
xorl %eax, %eax
leaq 0x1d41(%rip), %rcx      # 0x867f
cmpq $0x14, %rax
je 0x6950
movb (%rax,%rcx), %dl
movb %dl, -0x70(%rbp,%rax)
incq %rax
jmp 0x693e
movb %dil, -0x70(%rbp,%rax)
movb $0x0, -0x6f(%rbp,%rax)
leaq -0x70(%rbp), %rdi
callq 0x6818
nop
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regerror.c
// Function: regerror9
void
regerror(char *s)
{
	char buf[132];

	strncpy(buf, "regerror: ", sizeof(buf));
	strncat(buf, s, sizeof(buf)-1);
	strncat(buf, "\n", sizeof(buf)-1);
	write(2, buf, strlen(buf));
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
leaq 0x1d18(%rip), %rsi      # 0x8694
leaq -0xa0(%rbp), %rbx
movl $0x84, %edx
movq %rbx, %rdi
callq 0x2060
movl $0x83, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x20e0
movw $0xa, -0xa0(%rbp,%rax)
movq %rbx, %rdi
callq 0x20e0
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x20b0
pushq $0x1
popq %rdi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regexec.c
// Function: regexec9
extern int
regexec(Reprog *progp,	/* program to run */
	char *bol,	/* string to run machine on */
	Resub *mp,	/* subexpression elements */
	int ms)		/* number of elements at mp */
{
	Reljunk j;
	Relist relist0[LISTSIZE], relist1[LISTSIZE];
	int rv;

	/*
 	 *  use user-specified starting/ending location if specified
	 */
	j.starts = bol;
	j.eol = 0;
	if(mp && ms>0){
		if(mp->s.sp)
			j.starts = mp->s.sp;
		if(mp->e.ep)
			j.eol = mp->e.ep;
	}
	j.starttype = 0;
	j.startchar = 0;
	if(progp->startinst->type == RUNE && progp->startinst->r.r < Runeself) {
		j.starttype = RUNE;
		j.startchar = progp->startinst->r.r;
	}
	if(progp->startinst->type == BOL)
		j.starttype = BOL;

	/* mark space */
	j.relist[0] = relist0;
	j.relist[1] = relist1;
	j.reliste[0] = relist0 + nelem(relist0) - 2;
	j.reliste[1] = relist1 + nelem(relist1) - 2;

	rv = regexec1(progp, bol, mp, ms, &j);
	if(rv >= 0)
		return rv;
	rv = regexec2(progp, bol, mp, ms, &j);
	if(rv >= 0)
		return rv;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28f8, %rsp           # imm = 0x28F8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
testq %rdx, %rdx
sete %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
jne 0x6a20
movq (%r14), %rax
testq %rax, %rax
je 0x6a13
movq %rax, -0x58(%rbp)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x6a20
movq %rax, -0x50(%rbp)
andq $0x0, -0x60(%rbp)
movq (%r12), %rax
movl (%rax), %ecx
cmpl $0xc3, %ecx
je 0x6a4c
cmpl $0x7f, %ecx
jne 0x6a53
movl 0x8(%rax), %eax
cmpl $0x7f, %eax
ja 0x6a53
movl $0x7f, -0x60(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x6a53
movl $0xc3, -0x60(%rbp)
leaq -0x2920(%rbp), %rax
leaq -0x80(%rbp), %r8
movq %rax, (%r8)
leaq -0x14d0(%rbp), %rcx
movq %rcx, 0x8(%r8)
movl $0x1040, %edx           # imm = 0x1040
addq %rdx, %rax
movq %rax, 0x10(%r8)
addq %rdx, %rcx
movq %rcx, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x6b3a
movl %eax, %r13d
testl %eax, %eax
jns 0x6b25
movl $0x1fbd0, %edi          # imm = 0x1FBD0
callq 0x21b0
testq %rax, %rax
je 0x6b0d
movq %rax, -0x30(%rbp)
movl $0x1fbd0, %edi          # imm = 0x1FBD0
callq 0x21b0
pushq $-0x1
popq %r13
testq %rax, %rax
je 0x6b13
leaq -0x80(%rbp), %r8
movq -0x30(%rbp), %rcx
movq %rcx, (%r8)
movq %rax, 0x8(%r8)
movq %rax, %rdx
movq %rax, -0x38(%rbp)
movl $0x1f7c0, %eax          # imm = 0x1F7C0
addq %rax, %rcx
movq %rcx, 0x10(%r8)
movq %rdx, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x6b3a
movl %eax, %ebx
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rdi
jmp 0x6b1a
pushq $-0x1
popq %r13
jmp 0x6b25
movl %r13d, %ebx
movq -0x30(%rbp), %rdi
callq 0x2030
testl %ebx, %ebx
cmovnsl %ebx, %r13d
movl %r13d, %eax
addq $0x28f8, %rsp           # imm = 0x28F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phase[P]o/libregexp/regsub.c
// Function: regsub9
extern	void
regsub(char *sp,	/* source string */
	char *dp,	/* destination string */
	int dlen,
	Resub *mp,	/* subexpression elements */
	int ms)		/* number of elements pointed to by mp */
{
	char *ssp, *ep;
	int i;

	ep = dp+dlen-1;
	while(*sp != '\0'){
		if(*sp == '\\'){
			switch(*++sp){
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				i = *sp-'0';
				if(mp!=0 && mp[i].s.sp != 0 && ms>i)
					for(ssp = mp[i].s.sp;
					     ssp < mp[i].e.ep;
					     ssp++)
						if(dp < ep)
							*dp++ = *ssp;
				break;
			case '\\':
				if(dp < ep)
					*dp++ = '\\';
				break;
			case '\0':
				sp--;
				break;
			default:
				if(dp < ep)
					*dp++ = *sp;
				break;
			}
		}else if(*sp == '&'){
			if(mp!=0 && mp[0].s.sp != 0 && ms>0)
				for(ssp = mp[0].s.sp;
				     ssp < mp[0].e.ep; ssp++)
					if(dp < ep)
						*dp++ = *ssp;
		}else{
			if(dp < ep)
				*dp++ = *sp;
		}
		sp++;
	}
	*dp = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
addq %rsi, %rax
decq %rax
movzbl (%rdi), %r9d
cmpl $0x26, %r9d
je 0x6ece
cmpl $0x5c, %r9d
je 0x6e75
testl %r9d, %r9d
je 0x6f24
movq %rdi, %rdx
cmpq %rax, %rsi
jae 0x6f1c
movb %r9b, (%rsi)
incq %rsi
jmp 0x6f19
leaq 0x1(%rdi), %rdx
movb 0x1(%rdi), %r9b
movzbl %r9b, %r11d
leal -0x30(%r11), %r10d
cmpl $0xa, %r10d
jae 0x6f02
testq %rcx, %rcx
je 0x6f19
movq %r10, %rdi
shlq $0x4, %rdi
movq (%rcx,%rdi), %r9
testq %r9, %r9
sete %r11b
cmpl %r8d, %r10d
setge %r10b
orb %r11b, %r10b
jne 0x6f19
addq %rcx, %rdi
cmpq 0x8(%rdi), %r9
jae 0x6f19
cmpq %rax, %rsi
jae 0x6ec9
movb (%r9), %r10b
movb %r10b, (%rsi)
incq %rsi
incq %r9
jmp 0x6eb5
testq %rcx, %rcx
je 0x6f1c
testl %r8d, %r8d
setle %r9b
movq (%rcx), %rdx
testq %rdx, %rdx
sete %r10b
orb %r9b, %r10b
jne 0x6f1c
cmpq 0x8(%rcx), %rdx
jae 0x6f1c
cmpq %rax, %rsi
jae 0x6efd
movb (%rdx), %r9b
movb %r9b, (%rsi)
incq %rsi
incq %rdx
jmp 0x6ee9
testl %r11d, %r11d
je 0x6f1c
cmpl $0x5c, %r11d
jne 0x6f10
movb $0x5c, %r9b
cmpq %rax, %rsi
jb 0x6e6a
movq %rdx, %rdi
incq %rdi
jmp 0x6e45
movb $0x0, (%rsi)
popq %rbp
retq
nopl (%rax)