LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/cmd/blu.c
// Function: main
int main(int argc, const char* argv[]) {
	if (argc == 1) {
		repl();
	} else if (argc == 2) {
		if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
			help();
		} else if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-v") == 0) {
			version();
		} else {
			runFile(argv[1]);
		}
	} else {
		help();
		exit(64);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
cmpl $0x2, %edi
je 0x92e1
cmpl $0x1, %edi
jne 0x945e
xorl %eax, %eax
callq 0x2abd
movq %rax, %rbx
leaq 0x2ab1(%rip), %rdi      # 0xbd18
xorl %eax, %eax
callq 0x20f0
movq 0x6d63(%rip), %r13      # 0xffd8
movq (%r13), %rdx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2120
testq %rax, %rax
je 0x92ca
leaq 0x2a89(%rip), %r14      # 0xbd1b
movq %rsp, %r15
leaq 0x2a7c(%rip), %r12      # 0xbd18
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2be7
movq %r12, %rdi
xorl %eax, %eax
callq 0x20f0
movq (%r13), %rdx
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2120
testq %rax, %rax
jne 0x929c
movl $0xa, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x2b55
jmp 0x944b
movq 0x8(%rsi), %rbx
leaq 0x2a15(%rip), %rsi      # 0xbd01
movq %rbx, %rdi
callq 0x2130
testl %eax, %eax
je 0x9407
leaq 0x2a05(%rip), %rsi      # 0xbd08
movq %rbx, %rdi
callq 0x2130
testl %eax, %eax
je 0x9407
leaq 0x29f1(%rip), %rsi      # 0xbd0b
movq %rbx, %rdi
callq 0x2130
testl %eax, %eax
je 0x9431
leaq 0x29e4(%rip), %rsi      # 0xbd15
movq %rbx, %rdi
callq 0x2130
testl %eax, %eax
je 0x9431
xorl %eax, %eax
callq 0x2abd
movq %rax, %r14
leaq 0x29ea(%rip), %rsi      # 0xbd3c
movq %rbx, %rdi
callq 0x21c0
testq %rax, %rax
je 0x946d
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
movq %r15, %rdi
callq 0x2150
movq %rax, %r13
movq %r15, %rdi
callq 0x2100
leaq 0x1(%r13), %rdi
callq 0x2170
testq %rax, %rax
je 0x9475
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x2080
cmpq %r13, %rax
jb 0x947d
movb $0x0, (%r12,%rax)
movq %r15, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2be7
movl %eax, %ebx
movq %r12, %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2b55
cmpl $0x3, %ebx
je 0x9485
cmpl $0x2, %ebx
je 0x948f
cmpl $0x1, %ebx
jne 0x944b
movl $0x41, %edi
callq 0x21f0
leaq 0x2912(%rip), %rdi      # 0xbd20
leaq 0x2913(%rip), %rsi      # 0xbd28
leaq 0x2910(%rip), %rdx      # 0xbd2c
xorl %eax, %eax
callq 0x20f0
leaq 0x296c(%rip), %rdi      # 0xbd96
callq 0x2070
jmp 0x944b
leaq 0x28fb(%rip), %rdi      # 0xbd33
leaq 0x28ed(%rip), %rsi      # 0xbd2c
movl $0x1770, %edx           # imm = 0x1770
xorl %eax, %eax
callq 0x20f0
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x9499
movl $0x40, %edi
callq 0x21f0
movq %rbx, %rdi
callq 0x245c
movq %rbx, %rdi
callq 0x2438
movq %rbx, %rdi
callq 0x2414
movl $0x4b, %edi
callq 0x21f0
movl $0x46, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/compile.c
// Function: compile
int compile(FILE *fout) {
    int i;
    /* printf("start compilation\n"); */
    initSource();               /* getSourceの初期設定                  */
    token = nextToken();        /* 最初のトークン                       */
    blockBegin(FIRSTADDR);      /* これ以後の宣言は新しいブロックのもの */
    block(0);                   /* 0 はダミー（主ブロックの関数名はない） */
    finalSource();
    i = errorN();               /* エラーメッセージの個数               */
    if (i!=0)
        printf("%d errors\n", i);
    listCode(fout, 1);          /* 目的コードのリスト（必要なら）       */
    return i < MINERROR;        /* エラーメッセージの個数が少ないかどうかの判定 */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x462f
leaq 0xc(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4a16
movl 0x20(%r14), %eax
movl %eax, 0x6719(%rip)      # 0x9d88
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x66f9(%rip)     # 0x9d78
movups %xmm0, 0x66e2(%rip)     # 0x9d68
movl $0x2, %edi
callq 0x31a0
xorl %edi, %edi
callq 0x36d9
xorl %eax, %eax
callq 0x4772
xorl %eax, %eax
callq 0x4a0f
movl %eax, %ebp
testl %eax, %eax
je 0x36bb
leaq 0x1e92(%rip), %rdi      # 0x5544
movl %ebp, %esi
xorl %eax, %eax
callq 0x2090
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2444
xorl %eax, %eax
cmpl $0x3, %ebp
setl %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/compile.c
// Function: expression
void expression() {             /* 式のコンパイル                       */
    KeyId k;
    k = token.kind;
    if (k == Plus || k == Minus) {
        token = nextToken();
        term();
        if (k == Minus)
            genCodeO(neg);
    } else
        term();
    k = token.kind;
    while (k == Plus || k == Minus) {
        token = nextToken();
        term();
        if (k == Minus)
            genCodeO(sub);
        else
            genCodeO(add);
        k = token.kind;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x5d04(%rip), %r14d     # 0x9d68
leal -0xf(%r14), %eax
cmpl $0x1, %eax
ja 0x40ae
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a16
movl 0x20(%rbx), %eax
movl %eax, 0x5d03(%rip)      # 0x9d88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x5ce5(%rip)     # 0x9d78
movups %xmm0, 0x5cce(%rip)     # 0x9d68
callq 0x4120
cmpl $0x10, %r14d
jne 0x40b3
xorl %edi, %edi
callq 0x236e
jmp 0x40b3
callq 0x4120
movl 0x5caf(%rip), %eax      # 0x9d68
leal -0xf(%rax), %ecx
cmpl $0x1, %ecx
ja 0x4117
leaq 0xc(%rsp), %rbx
xorl %ebp, %ebp
cmpl $0x10, %eax
sete %bpl
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a16
movl 0x2c(%rsp), %eax
movl %eax, 0x5ca5(%rip)      # 0x9d88
movups 0xc(%rsp), %xmm0
movups 0x1c(%rsp), %xmm1
movups %xmm1, 0x5c84(%rip)     # 0x9d78
movups %xmm0, 0x5c6d(%rip)     # 0x9d68
callq 0x4120
incl %ebp
movl %ebp, %edi
callq 0x236e
movl 0x5c59(%rip), %eax      # 0x9d68
leal -0xf(%rax), %ecx
cmpl $0x2, %ecx
jb 0x40c6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/compile.c
// Function: term
void term() {                   /* 式の項のコンパイル                   */
    KeyId k;
    factor();
    k = token.kind;
    while (k == Mult || k == Div) {
        token = nextToken();
        factor();
        if (k == Mult)
            genCodeO(mul);
        else
            genCodeO(div);
        k = token.kind;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x419c
movl 0x5c35(%rip), %r14d     # 0x9d68
leal -0x11(%r14), %eax
cmpl $0x1, %eax
ja 0x4194
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a16
movl 0x24(%rsp), %eax
movl %eax, 0x5c33(%rip)      # 0x9d88
movups 0x4(%rsp), %xmm0
movups 0x14(%rsp), %xmm1
movups %xmm1, 0x5c12(%rip)     # 0x9d78
movups %xmm0, 0x5bfb(%rip)     # 0x9d68
callq 0x419c
xorl %edi, %edi
cmpl $0x11, %r14d
setne %dil
addl $0x3, %edi
callq 0x236e
movl 0x5bdd(%rip), %r14d     # 0x9d68
leal -0x11(%r14), %eax
cmpl $0x2, %eax
jb 0x4141
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/compile.c
// Function: condition
void condition() {              /* 条件式のコンパイル                   */
    KeyId k;
    if (token.kind == Odd) {
        token = nextToken();
        expression();
        genCodeO(odd);
    } else {
        expression();
        k = token.kind;
        switch (k) {
        case Equal:
        case Lss:
        case Gtr:
        case NotEq:
        case LssEq:
        case GtrEq:
            break;
        default:
            errorType("rel-op");
            break;
        }
        token = nextToken();
        expression();
        switch (k) {
        case Equal: genCodeO(eq); break;
        case Lss: genCodeO(ls); break;
        case Gtr: genCodeO(gr); break;
        case NotEq: genCodeO(neq); break;
        case LssEq: genCodeO(lseq); break;
        case GtrEq: genCodeO(greq); break;
        default:
            /* ishii */
            errorType("rel-op");
            break;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0xa, 0x58e7(%rip)      # 0x9d68
jne 0x44c7
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a16
movl 0x20(%rbx), %eax
movl %eax, 0x58ed(%rip)      # 0x9d88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x58cf(%rip)     # 0x9d78
movups %xmm0, 0x58b8(%rip)     # 0x9d68
callq 0x4055
movl $0x5, %edi
callq 0x236e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x4055
movl 0x5895(%rip), %r14d     # 0x9d68
addl $-0x15, %r14d
cmpl $0x6, %r14d
jb 0x44e9
leaq 0xef9(%rip), %rdi       # 0x53dd
callq 0x4849
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a16
movl 0x20(%rbx), %eax
movl %eax, 0x5887(%rip)      # 0x9d88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x5869(%rip)     # 0x9d78
movups %xmm0, 0x5852(%rip)     # 0x9d68
callq 0x4055
cmpl $0x5, %r14d
ja 0x456a
leaq 0xe88(%rip), %rax       # 0x53b0
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x6, %edi
jmp 0x44ba
movl $0xa, %edi
jmp 0x44ba
movl $0x8, %edi
jmp 0x44ba
movl $0x9, %edi
jmp 0x44ba
movl $0x7, %edi
jmp 0x44ba
movl $0xb, %edi
jmp 0x44ba
leaq 0xe6c(%rip), %rdi       # 0x53dd
callq 0x4849
jmp 0x44bf
nop
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/wc.c
// Function: wc_get_byte_count
off_t wc_get_byte_count(int fd){
    struct stat s;
    if(fstat(fd, &s) < 0){
        fprintf(stderr, "wc: %s\n", strerror(errno));
        exit(1);
    }
    return s.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x90(%rbp), %rsi
callq 0x10e0
testl %eax, %eax
js 0x14c4
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
callq 0x1110
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/wc.c
// Function: wc_get_nl_count
size_t wc_get_nl_count(int fd){
    char buf[4096];
    size_t sum = 0;
    ssize_t n;
    lseek(fd, 0, SEEK_SET);
    while((n = read(fd, buf, 4095)) > 0){
        for(size_t i = 0; i < n; i++){
            if(buf[i] == '\n'){
                sum++;
            }
        }
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %edi, %ebx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1060
leaq -0x1020(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
movl %ebx, %edi
callq 0x1070
testq %rax, %rax
jle 0x153f
xorl %r14d, %r14d
leaq -0x1020(%rbp), %r15
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpb $0xa, -0x1020(%rbp,%rcx)
sete %dl
addq %rdx, %r14
incq %rcx
cmpq %rcx, %rax
jne 0x1513
movl $0xfff, %edx            # imm = 0xFFF
movl %ebx, %edi
movq %r15, %rsi
callq 0x1070
testq %rax, %rax
jg 0x1509
movq %r14, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/wc.c
// Function: wc_get_word_count
size_t wc_get_word_count(int fd){
    char buf[4096];
    size_t num = 0;
    ssize_t n;
    lseek(fd, 0, SEEK_SET);
    while((n = read(fd, buf, 4096)) > 0){
        for(size_t i = 1; i < n; i++){
            if(!isspace(buf[i-1]) && isspace(buf[i])){
                num++;
            }
        }
    }
    return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edi, %ebx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1060
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
callq 0x1070
testq %rax, %rax
jle 0x15ec
movq %rax, %r12
xorl %r14d, %r14d
leaq -0x1020(%rbp), %r15
cmpq $0x2, %r12
jb 0x15d5
callq 0x10f0
movq (%rax), %rax
movl $0x1, %ecx
movsbq -0x1021(%rbp,%rcx), %rdx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x15cd
movsbq -0x1020(%rbp,%rcx), %rdx
movzwl (%rax,%rdx,2), %edx
btl $0xd, %edx
adcq $0x0, %r14
incq %rcx
cmpq %rcx, %r12
jne 0x15a8
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
movq %r15, %rsi
callq 0x1070
movq %rax, %r12
testq %rax, %rax
jg 0x1595
movq %r14, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/wc.c
// Function: main
int main(int argc, char **argv){
    struct wc_args *args = calloc(1, sizeof(struct wc_args));
    if(args == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    args = parse_arg(args, argc, argv);
    for(int i = 0; i < args->fcount; i++){
        int fd = open(args->files[i], O_RDONLY);
        if(!strcmp(args->files[i], "-")){
            fd = STDIN_FILENO;
        }
        if(fd < 0){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
            return 1;
        }
        /*if(args->byte_count){
            puts("byte count");
            printf("%zu\n", wc_get_byte_count(fd));
        }
        if(args->line_count){
            puts("line count");
            printf("%zu\n", wc_get_nl_count(fd));
        }
        if(args->word_count){
            puts("word count");
            printf("%zu\n", wc_get_word_count(fd));
        }*/
        printf("  %zu %zu %zu %s\n", wc_get_nl_count(fd), wc_get_word_count(fd), wc_get_byte_count(fd), args->files[i]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl %edi, %ebx
movl $0x1, %edi
movl $0x18, %esi
callq 0x1080
testq %rax, %rax
je 0x16fa
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x12ac
cmpl $0x0, 0x10(%r14)
jle 0x16e4
movq %r15, -0x38(%rbp)
xorl %r12d, %r12d
movl $0x0, -0x2c(%rbp)
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10b0
movl %eax, %ebx
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
leaq 0x9e8(%rip), %rsi       # 0x2060
callq 0x1090
testl %eax, %eax
cmovel %eax, %ebx
testl %ebx, %ebx
js 0x16d2
movl %ebx, %edi
callq 0x14c9
movq %rax, %r15
movl %ebx, %edi
callq 0x1550
movq %rax, %r13
movl %ebx, %edi
callq 0x149c
movq 0x8(%r14), %rcx
movq (%rcx,%r12,8), %r8
leaq 0x9c2(%rip), %rdi       # 0x2072
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
testl %ebx, %ebx
js 0x16e8
incq %r12
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jl 0x1656
jmp 0x16e4
movq -0x38(%rbp), %rdi
callq 0x1148
movl $0x1, -0x2c(%rbp)
jmp 0x16c0
xorl %eax, %eax
jmp 0x16eb
movl -0x2c(%rbp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x1183
movl $0x1, %eax
jmp 0x16eb
// File: /workspace/github_c_makefile_star2_O1/ddrown[P]pretend-ntp/ntp-exit.c
// Function: main
int main(int argc, char *argv[]) {
  struct ntp_msg buf;
  int sock;
  struct sockaddr_in addr;

  if(argc < 3) {
    printf("%s [ip] [port]\n", argv[0]);
    exit(1);
  }
  if(inet_aton(argv[1], &addr.sin_addr) == INADDR_NONE) {
    printf("invalid ip %s\n", argv[1]);
    exit(1);
  }
  addr.sin_port = htons(strtoul(argv[2], NULL, 10));
  addr.sin_family = AF_INET;

  memset(&buf, 0, sizeof(buf));
  buf.version = NTP_VERS_4;
  buf.mode = NTP_MODE_PRIV;

  sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (sock == -1) {
    perror_exit("socket");
  }
  sendto(sock, &buf, sizeof(buf), 0, &addr, sizeof(addr));
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jle 0x1292
movq 0x8(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1080
cmpl $-0x1, %eax
je 0x129e
movq 0x10(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x10c0
rolw $0x8, %ax
movw %ax, 0x2(%rsp)
movw $0x2, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x27, 0x10(%rsp)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x10e0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x126e
leaq 0xdba(%rip), %rdi       # 0x2023
callq 0x1930
leaq 0x10(%rsp), %rsi
movq %rsp, %r8
movl $0x30, %edx
movl %ebx, %edi
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x1070
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
movq (%rbx), %rsi
leaq 0xd68(%rip), %rdi       # 0x2004
jmp 0x12a9
movq 0x8(%rbx), %rsi
leaq 0xd6b(%rip), %rdi       # 0x2014
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x10d0
nop
// File: /workspace/github_c_makefile_star2_O1/keiranrowan[P]tiny-core/./src/yes.c
// Function: main
int main(int argc, char **argv) {
    if (argc > 1 && argc < 3) {
        if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
            printf("yes [STRING]...\nPrints y or given string repeatedly\n");
        } else {
            for(;;) {
                printf("%s\n", argv[1]);
            }
        }
    } else {
        for(;;) {
            printf("y\n");
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x118d
movq %rsi, %rbx
movq 0x8(%rsi), %r14
leaq 0xea1(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x119e
leaq 0xe91(%rip), %rsi       # 0x2007
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x119e
movq 0x8(%rbx), %rdi
callq 0x1030
jmp 0x1182
leaq 0xeac(%rip), %rbx       # 0x2040
movq %rbx, %rdi
callq 0x1030
jmp 0x1194
leaq 0xe69(%rip), %rdi       # 0x200e
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/sha1/main.c
// Function: selftest
static int
selftest(void)
{
	SHA1_CTX ctx;
	uint8_t hbuf[20];
	char hbuf_hex[41];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing SHA1 of \"%s\"...", tests[i].s);
		SHA1_Init(&ctx);
		SHA1_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		SHA1_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 20);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed SHA1: %s\n", hbuf_hex);
			printf("Correct SHA1:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl $0x8, %ebx
leaq 0x4c(%rsp), %r14
leaq 0x20(%rsp), %r12
xorl %r15d, %r15d
leaq 0x5439(%rip), %rax      # 0x6d60
movq -0x8(%rbx,%rax), %rbp
movq (%rbx,%rax), %r13
leaq 0x26e4(%rip), %rdi      # 0x401b
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
callq 0x1aa8
movq %rbp, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1ac3
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2a2e
movl $0x14, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x32ec
movq %r12, %rdi
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
je 0x19bf
leaq 0x2a16(%rip), %rdi      # 0x43a9
callq 0x1090
leaq 0x2696(%rip), %rdi      # 0x4035
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x2698(%rip), %rdi      # 0x4048
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
incq %r15
jmp 0x19cb
leaq 0x29da(%rip), %rdi      # 0x43a0
callq 0x1090
addq $0x10, %rbx
cmpq $0x98, %rbx
jne 0x1920
xorl %eax, %eax
testq %r15, %r15
setne %al
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/sha1/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	SHA1_CTX ctx;
	uint8_t hbuf[20];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	SHA1_Init(&ctx);
	for (i = 0; i < nreps; i++)
		SHA1_Update(&ctx, buf, buflen);
	SHA1_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1c(%rsp), %rdi
callq 0x1aa8
testq %rbx, %rbx
je 0x1a8a
leaq 0x1c(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ac3
decq %rbx
jne 0x1a77
movq %rsp, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x2a2e
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_SHA1_Final
void
SHA1_Final(uint8_t digest[20], SHA1_CTX * ctx)
{

	/* Add padding. */
	SHA1_Pad(ctx);

	/* Write the hash. */
	be32enc_vect(digest, ctx->state, 20);

	/* Clear the context state. */
	insecure_memzero(ctx, sizeof(SHA1_CTX));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl 0x14(%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%rsp,%rax,4)
incq %rax
cmpq $0x2, %rax
jne 0x2a3a
movl 0x18(%rbx), %eax
shrl $0x3, %eax
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orl $0x38, %edx
subl %eax, %edx
leaq 0x46a4(%rip), %rsi      # 0x7110
movq %rbx, %rdi
callq 0x1ac3
movq %rsp, %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x1ac3
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x2a86
leaq 0x46f9(%rip), %rax      # 0x7198
movq (%rax), %rax
movl $0x5c, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_SHA1_Buf
void
SHA1_Buf(const void * in, size_t len, uint8_t digest[20])
{
	SHA1_CTX ctx;

	SHA1_Init(&ctx);
	SHA1_Update(&ctx, in, len);
	SHA1_Final(digest, &ctx);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0xc(%rsp), %r14
movl $0x0, 0x18(%r14)
movaps 0x1909(%rip), %xmm0     # 0x43e0
movups %xmm0, (%r14)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x1ac3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a2e
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_HMAC_SHA1_Init
void
HMAC_SHA1_Init(HMAC_SHA1_CTX * ctx, const void * _k, size_t Klen)
{
	uint8_t pad[64];
	uint8_t khash[20];
	const uint8_t * K = _k;
	size_t i;

	/* If Klen > 64, the key is really SHA1(K). */
	if (Klen > 64) {
		SHA1_Init(&ctx->ictx);
		SHA1_Update(&ctx->ictx, K, Klen);
		SHA1_Final(khash, &ctx->ictx);
		K = khash;
		Klen = 20;
	}

	/* Inner SHA1 operation is SHA1(K xor [block of 0x36] || data). */
	SHA1_Init(&ctx->ictx);
	memset(pad, 0x36, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA1_Update(&ctx->ictx, pad, 64);

	/* Outer SHA1 operation is SHA1(K xor [block of 0x5c] || hash). */
	SHA1_Init(&ctx->octx);
	memset(pad, 0x5c, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA1_Update(&ctx->octx, pad, 64);

	/* Clean the stack. */
	insecure_memzero(khash, 20);
	insecure_memzero(pad, 64);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x41, %rdx
jb 0x2b5b
movl $0x0, 0x18(%r15)
movaps 0x18b6(%rip), %xmm0     # 0x43e0
movups %xmm0, (%r15)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ac3
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a2e
movl $0x14, %r14d
movl $0x0, 0x18(%r15)
movaps 0x1876(%rip), %xmm0     # 0x43e0
movups %xmm0, (%r15)
movl $0xc3d2e1f0, %r13d      # imm = 0xC3D2E1F0
movq %r13, 0x10(%r15)
movaps 0x1871(%rip), %xmm0     # 0x43f0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %r14, %r14
je 0x2ba7
xorl %eax, %eax
movb (%rbx,%rax), %cl
xorb %cl, (%rsp,%rax)
incq %rax
cmpq %rax, %r14
jne 0x2b99
movq %rsp, %r12
movl $0x40, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ac3
leaq 0x5c(%r15), %rdi
movl $0x0, 0x74(%r15)
movaps 0x1813(%rip), %xmm0     # 0x43e0
movups %xmm0, 0x5c(%r15)
movq %r13, 0x6c(%r15)
movaps 0x1823(%rip), %xmm0     # 0x4400
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
testq %r14, %r14
je 0x2c09
xorl %eax, %eax
movb (%rbx,%rax), %cl
xorb %cl, (%rsp,%rax)
incq %rax
cmpq %rax, %r14
jne 0x2bfb
movq %rsp, %rbx
movl $0x40, %edx
movq %rbx, %rsi
callq 0x1ac3
leaq 0x4578(%rip), %r14      # 0x7198
movq (%r14), %rax
leaq 0x40(%rsp), %rdi
movl $0x14, %esi
callq *%rax
movq (%r14), %rax
movl $0x40, %esi
movq %rbx, %rdi
callq *%rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_HMAC_SHA1_Final
void
HMAC_SHA1_Final(uint8_t digest[20], HMAC_SHA1_CTX * ctx)
{
	uint8_t ihash[20];

	/* Finish the inner SHA1 operation. */
	SHA1_Final(ihash, &ctx->ictx);

	/* Feed the inner hash to the outer SHA1 operation. */
	SHA1_Update(&ctx->octx, ihash, 20);

	/* Finish the outer SHA1 operation. */
	SHA1_Final(digest, &ctx->octx);

	/* Clean the stack. */
	insecure_memzero(ihash, 20);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2a2e
addq $0x5c, %rbx
movl $0x14, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ac3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a2e
leaq 0x4509(%rip), %rax      # 0x7198
movq (%rax), %rax
movl $0x14, %esi
movq %r15, %rdi
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/err.c
// Function: c_error
void c_error(s_pos *pos, const char *msg, ...) {
	if (pos != NULL) {
		fprintf(stderr, "%s:%i:%i: ",
			pos->fname, pos->line, pos->col);
	}
	va_list args;
	va_start(args, msg);
	fputs("ERROR: ", stderr);
	vfprintf(stderr, msg, args);
	va_end(args);

	c_errflag = 1;
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x32ae
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x32d8
movq 0x10d3e(%rip), %rax     # 0x13ff8
movq (%rax), %rax
movq 0x10(%rdi), %rdx
movl (%rdi), %ecx
movl 0x4(%rdi), %r8d
leaq 0x9dce(%rip), %rsi      # 0xd09c
movq %rax, %rdi
xorl %eax, %eax
callq 0x3130
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0x10cf4(%rip), %r15     # 0x13ff8
movq (%r15), %rsi
leaq 0x9d99(%rip), %rdi      # 0xd0a7
callq 0x30f0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31f0
movl $0x1, 0x11149(%rip)     # 0x14474
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/err.c
// Function: c_warn
void c_warn(s_pos *pos, const char *msg, ...) {
	if (pos != NULL) {
		fprintf(stderr, "%s:%i:%i: ",
			pos->fname, pos->line, pos->col);
	}
	va_list args;
	va_start(args, msg);
	fputs("WARNING: ", stderr);
	vfprintf(stderr, msg, args);
	va_end(args);

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x3396
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x33c0
movq 0x10c56(%rip), %rax     # 0x13ff8
movq (%rax), %rax
movq 0x10(%rdi), %rdx
movl (%rdi), %ecx
movl 0x4(%rdi), %r8d
leaq 0x9ce6(%rip), %rsi      # 0xd09c
movq %rax, %rdi
xorl %eax, %eax
callq 0x3130
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0x10c0c(%rip), %r15     # 0x13ff8
movq (%r15), %rsi
leaq 0x9cb9(%rip), %rdi      # 0xd0af
callq 0x30f0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31f0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ast.c
// Function: astn_new
ast_n *astn_new(int kind, int s_kind, token t) {
	ast_n *node = calloc(1, sizeof(struct AST_NODE));
	node->kind = kind;

	switch (kind) {
		case DECL:
			node->dat.decl.kind = s_kind;
			break;
		case EXPR:
			node->dat.expr.kind = s_kind;
			break;
		case STMT:
			node->dat.stmt.kind = s_kind;
			break;
	}
	node->tok = t;

	return node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x3100
movl %ebp, (%rax)
cmpl $0x2, %ebp
ja 0x3592
movl %ebx, 0x8(%rax)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x50(%rax)
movups %xmm1, 0x40(%rax)
movups %xmm0, 0x30(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ast.c
// Function: astn_del
void astn_del(ast_n *node) {
	if (node == NULL)
		return;

	//note: don't delete symbols here
	switch (node->kind) {
		case DECL:
			astn_del(node->dat.decl.init);
			astn_del(node->dat.decl.block);
			astn_del(node->dat.decl.next);
			break;
		case EXPR:
			if (node->dat.expr.type != NULL)
				type_del(node->dat.expr.type);
			astn_del(node->dat.expr.left);
			astn_del(node->dat.expr.right);
			break;
		case STMT:
			if (node->dat.stmt.lbl != NULL)
				free(node->dat.stmt.lbl);
			astn_del(node->dat.stmt.expr);
			astn_del(node->dat.stmt.body);
			astn_del(node->dat.stmt.else_body);
			break;
	}
	astn_del(node->next);

	//Free node data type tags
	if (node->tok.dtype != NULL)
		type_del(node->tok.dtype);

	free(node);
	return;
}

// Assembly:
testq %rdi, %rdi
je 0x35cc
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x35dd
cmpl $0x1, %eax
je 0x35cd
testl %eax, %eax
je 0x35eb
jmp 0x3606
retq
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x35f4
callq 0xc2c4
jmp 0x35f4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x35eb
callq 0x3030
movq 0x18(%rbx), %rdi
callq 0x35b1
movq 0x20(%rbx), %rdi
callq 0x35b1
movq 0x28(%rbx), %rdi
callq 0x35b1
movq 0x60(%rbx), %rdi
callq 0x35b1
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x361d
callq 0xc2c4
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/eval.c
// Function: do_op
long long do_op(int op, int lhs, int rhs, int trs) {
	switch (op) {
		case TOK_QMK:		return (lhs) ? rhs : trs;
		case TOK_NOT:		return !lhs;
		case TOK_TLD:		return ~lhs;
		case TOK_ASR:		return lhs * rhs;
		case TOK_DIV:		return lhs / rhs;
		case TOK_MOD:		return lhs % rhs;
		case TOK_ADD:		return lhs + rhs;
		case TOK_SUB:		return lhs - rhs;
		case TOK_LSHIFT:	return lhs << rhs;
		case TOK_RSHIFT:	return lhs >> rhs;
		case TOK_GTH:		return lhs > rhs;
		case TOK_LTH:		return lhs < rhs;
		case TOK_GEQ:		return lhs >= rhs;
		case TOK_LEQ:		return lhs <= rhs;
		case TOK_EQ: 		return lhs == rhs;
		case TOK_NEQ:		return lhs != rhs;
		case TOK_AND:		return lhs & rhs;
		case TOK_XOR:		return lhs ^ rhs;
		case TOK_OR:		return lhs | rhs;
		case TOK_LOGIC_AND:	return lhs && rhs;
		case TOK_LOGIC_OR:	return lhs || rhs;
		case TOK_CMM:		return lhs, rhs;
	}
	return -1;
}

// Assembly:
movq $-0x1, %rax
addl $-0x3, %edi
cmpl $0x23, %edi
ja 0x3928
movl %edx, %r8d
leaq 0x982d(%rip), %rdx      # 0xd0bc
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
testl %esi, %esi
cmovel %ecx, %r8d
jmp 0x3925
testl %esi, %esi
setne %al
testl %r8d, %r8d
setne %cl
andb %al, %cl
movzbl %cl, %eax
retq
movl %r8d, %ecx
sarl %cl, %esi
jmp 0x393e
xorl %eax, %eax
cmpl %r8d, %esi
setle %al
retq
notl %esi
jmp 0x393e
xorl %eax, %eax
cmpl %r8d, %esi
setg %al
retq
xorl %eax, %eax
testl %esi, %esi
jmp 0x390e
addl %esi, %r8d
jmp 0x3925
movl %esi, %eax
cltd
idivl %r8d
cltq
retq
xorl %eax, %eax
cmpl %r8d, %esi
setl %al
retq
movl %esi, %eax
cltd
idivl %r8d
movslq %edx, %rax
retq
andl %esi, %r8d
jmp 0x3925
xorl %eax, %eax
cmpl %r8d, %esi
setge %al
retq
xorl %eax, %eax
cmpl %r8d, %esi
sete %al
retq
subl %r8d, %esi
jmp 0x393e
imull %esi, %r8d
jmp 0x3925
xorl %esi, %r8d
jmp 0x3925
orl %esi, %r8d
movslq %r8d, %rax
retq
xorl %eax, %eax
orl %esi, %r8d
jmp 0x3935
xorl %eax, %eax
cmpl %r8d, %esi
setne %al
retq
movl %r8d, %ecx
shll %cl, %esi
movslq %esi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/eval.c
// Function: do_calc
void do_calc(vector *ops, vector *vals) {
	int op = (long long)vector_pop(ops);
	int trs = (op == TOK_QMK) ? (long long)vector_pop(vals) : 0;
	int rhs = (!is_unary(op)) ? (long long)vector_pop(vals) : 0;
	int lhs = (long long)vector_pop(vals);
	long long res = do_op(op, lhs, rhs, trs);
	vector_push(vals, (void*)res);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xca96
movq %rax, %r14
xorl %r15d, %r15d
movl $0x0, %r12d
cmpl $0xf, %r14d
jne 0x396f
movq %rbx, %rdi
callq 0xca96
movq %rax, %r12
cmpl $0x32, %r14d
ja 0x3988
movl %r14d, %eax
movabsq $0x4000201000000, %rcx  # imm = 0x4000201000000
btq %rax, %rcx
jb 0x3993
movq %rbx, %rdi
callq 0xca96
movq %rax, %r15
movq %rbx, %rdi
callq 0xca96
movl %r14d, %edi
movl %eax, %esi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x3872
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xca91
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/eval.c
// Function: eval_constexpr_ast
int _eval_constexpr_ast(ast_n *node, int *err) {
	if (node == NULL) return 0;

	//Perform action
	s_pos *loc = &node->tok.loc;
	int l_res = _eval_constexpr_ast(node->dat.expr.left, err);
	int r_res = _eval_constexpr_ast(node->dat.expr.right, err);
	int t_res = 0;
	switch (node->dat.expr.kind) {
		case EXPR_COND: {
			ast_n *res = node->dat.expr.right;
			r_res = _eval_constexpr_ast(res->dat.expr.left, err);
			t_res = _eval_constexpr_ast(res->dat.expr.right, err);
			}
			return do_op(node->tok.type, l_res, r_res, t_res); 
		case EXPR_COND_RES:
			return 0;
		case EXPR_LOGIC_OR:
		case EXPR_LOGIC_AND:
		case EXPR_OR:
		case EXPR_XOR:
		case EXPR_AND:
		case EXPR_GTH:
		case EXPR_LTH:
		case EXPR_GEQ:
		case EXPR_LEQ:
		case EXPR_LSHIFT:
		case EXPR_RSHIFT:
		case EXPR_EQ:
		case EXPR_NEQ:
		case EXPR_ADD:
		case EXPR_SUB:
		case EXPR_MUL:
		case EXPR_DIV:
			return do_op(node->tok.type, l_res, r_res, 0);
		case EXPR_MOD:
		case EXPR_POS:
		case EXPR_NEG:
		case EXPR_NOT:
		case EXPR_LOGIC_NOT:
			return do_op(node->tok.type, l_res, 0, 0);
			break;
		case EXPR_CAST:
		case EXPR_REF:
		case EXPR_DEREF:
		case EXPR_INC_PRE:
		case EXPR_DEC_PRE:
		case EXPR_ARRAY:
		case EXPR_CALL:
		case EXPR_MEMB:
		case EXPR_PTR_MEMB:
		case EXPR_INC_POST:
		case EXPR_DEC_POST:
			c_error(loc, "Invalid operation in constant expression\n");
			return 0;
		case EXPR_IDENT:
			c_error(loc, "Identifier in constant expression\n");
			return 0;
		case EXPR_CONST:
			if (node->tok.dtype->kind == TYPE_FLOAT)
				c_error(loc, "Floating point value in constant expression\n");
			return node->tok.dat.ival;
		default:
			c_error(loc, "Invalid constant expression\n");
			break;
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3d62
movq %rsi, %r12
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq 0x20(%rdi), %rdi
callq 0x3ce2
movl %eax, %ebp
movq 0x28(%r14), %rdi
movq %r12, %rsi
callq 0x3ce2
movl 0x8(%r14), %ecx
decl %ecx
cmpl $0x24, %ecx
ja 0x3dc0
leaq 0x9424(%rip), %rdx      # 0xd14c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x30(%r14), %edi
movl %ebp, %esi
movl %eax, %edx
jmp 0x3d58
leaq 0x95d8(%rip), %rsi      # 0xd31a
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x3250
jmp 0x3d62
movl 0x30(%r14), %edi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3872
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r14), %r15
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0x3ce2
movl %eax, %ebx
movq 0x28(%r15), %rdi
movq %r12, %rsi
callq 0x3ce2
movl 0x30(%r14), %edi
movl %ebp, %esi
movl %ebx, %edx
movl %eax, %ecx
jmp 0x3d5a
leaq 0x9655(%rip), %rsi      # 0xd3f3
jmp 0x3d42
movq 0x58(%r14), %rax
cmpl $0x7, (%rax)
jne 0x3dba
leaq 0x94f4(%rip), %rsi      # 0xd2a4
movq %r15, %rdi
xorl %eax, %eax
callq 0x3250
movl 0x50(%r14), %ebx
jmp 0x3d62
leaq 0x964f(%rip), %rsi      # 0xd416
movq %r15, %rdi
xorl %eax, %eax
callq 0x3250
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3d62
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/eval.c
// Function: eval_constexpr_ast
int eval_constexpr_ast(ast_n *root, int *err) {
	int eflag_prev = c_errflag;
	int res = _eval_constexpr_ast(root, err);
	*err = !eflag_prev && c_errflag;
	return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x1068e(%rip), %r14     # 0x14474
cmpl $0x0, (%r14)
sete %bpl
callq 0x3ce2
cmpl $0x0, (%r14)
setne %cl
andb %bpl, %cl
movzbl %cl, %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_numlabel
char *gen_numlabel(asm_f *f) {
	//Generate a label and store it in the map
	int num = f->lnum++;
	char *buf = malloc(16);
	snprintf(buf, 16, ".L%i", num);
	map_insert(&f->labels, buf, buf);
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %r14d
leal 0x1(%r14), %eax
movl %eax, 0x28(%rdi)
movl $0x10, %edi
callq 0x3170
movq %rax, %r15
leaq 0x96c5(%rip), %rdx      # 0xd4f4
movl $0x10, %esi
movq %rax, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x30d0
addq $0x30, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0xc840
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_expr_bitwise
void gen_expr_bitwise(asm_f *f, ast_n *n) {
	int bit_i = -1;
	switch (n->dat.expr.kind) {
		case EXPR_AND: bit_i = INST_AND; break;
		case EXPR_OR:  bit_i = INST_OR;  break;
		case EXPR_XOR: bit_i = INST_XOR; break;
	}

	//Perform bitwise operation
	gen_expr(f, n->dat.expr.left);
	asmf_add_inst(f, mk_inst(INST_PUSH, 1, mk_oprd(OPRD_REG, RAX)));
	gen_expr(f, n->dat.expr.right);
	asmf_add_inst(f, mk_inst(INST_POP, 1, mk_oprd(OPRD_REG, RBX)));
	asmf_add_inst(f, mk_inst(bit_i, 2, 
		mk_oprd(OPRD_REG, RAX),
		mk_oprd(OPRD_REG, RBX)
	));

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
addl $-0x5, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x2, %eax
ja 0x446a
movl %eax, %eax
leaq 0x9081(%rip), %rcx      # 0xd4e8
movl (%rcx,%rax,4), %ebp
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x4173
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x36, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x4173
leaq 0x88(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x5220
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x37, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
leaq 0x68(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
leaq 0x48(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x5220
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
movl $0x2, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_expr_deref
void gen_expr_deref(asm_f *f, ast_n *n) {
	gen_expr(f, n->dat.expr.left);
	asmf_add_inst(f, mk_inst(INST_MOV, 2, 
		mk_oprd(OPRD_REG, RAX),
		mk_oprd_ex(OPRD_REG, RAX, DEREF, 0)
	));

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
callq 0x4173
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
leaq 0x40(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x5230
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x3e, %edi
movl $0x2, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_expr_array
void gen_expr_array(asm_f *f, ast_n *n) {
	gen_expr(f, n->dat.expr.left);
	asmf_add_inst(f, mk_inst(INST_MOV, 2, 
		mk_oprd(OPRD_REG, RBX),
		mk_oprd(OPRD_REG, RAX)
	));

	ast_n *ofs = n->dat.expr.right;
	if (ofs->dat.expr.kind == EXPR_CONST) {
		if (ofs->dat.expr.sym->type->kind != TYPE_INT) {
			c_error(NULL, "Array offset must be an integer\n");
			return;
		}
		asmf_add_inst(f, mk_inst(INST_MOV, 2, 
			mk_oprd(OPRD_REG, RAX),
			mk_oprd_ex(OPRD_REG, RAX, DEREF_IMM, 0) //placeholder
		));
	}

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
callq 0x4173
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x5220
leaq 0x88(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x3e, %edi
movl $0x2, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
movq 0x28(%r14), %rax
cmpl $0x25, 0x8(%rax)
jne 0x4737
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x6, (%rax)
jne 0x4727
leaq 0x68(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
leaq 0x48(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x5230
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x3e, %edi
movl $0x2, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
jmp 0x4737
leaq 0x8dcb(%rip), %rsi      # 0xd4f9
xorl %edi, %edi
xorl %eax, %eax
callq 0x3250
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_stmt_cmpd
void gen_stmt_cmpd(asm_f *f, ast_n *n) {
	ast_n *n_cur = n->next;
	while (n_cur != NULL) {
		switch (n_cur->kind) {
			case STMT: gen_stmt(f, n_cur); break;
			case DECL: gen_decl(f, n_cur); break;
		}
		n_cur = n_cur->next;
	}
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x60(%rsi), %r14
testq %r14, %r14
je 0x48fb
movq %rdi, %rbx
cmpl $0x2, (%r14)
jne 0x48f2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4903
movq 0x60(%r14), %r14
testq %r14, %r14
jne 0x48e1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_stmt
void gen_stmt(asm_f *f, ast_n *n) {
	switch (n->dat.stmt.kind) {
		case STMT_EXPR:   gen_expr(f, n->dat.stmt.expr);break;
		case STMT_CMPD:   gen_stmt_cmpd(f, n); 		break;
		case STMT_IF: 	  gen_stmt_if(f, n);		break;
		case STMT_SWITCH: gen_stmt_switch(f, n);	break;
		case STMT_WHILE:
		case STMT_FOR:
		case STMT_DO_WHILE:
			gen_stmt_loop(f, n);
			break;
		case STMT_LABEL:
			gen_stmt_label(f, n);
			break;
		case STMT_CASE:
			c_error(NULL, "Case label not inside switch statement\n");
			break;
		case STMT_DEFAULT:
			c_error(NULL, "'default' label not inside switch statement\n");
			break;
		case STMT_GOTO: gen_stmt_goto(f, n);		break;
		case STMT_CONTINUE:
			if (f->cont_tgt == NULL) {
				c_error(NULL, "'continue' not inside loop\n");
				break;
			}
			asmf_add_inst(f, mk_inst(INST_JMP, 1,
				mk_oprd_label(f->cont_tgt)
			));
			break;
		case STMT_BREAK:
			if (f->break_tgt == NULL) {
				c_error(NULL, "'break' not inside loop or switch\n");
				break;
			}
			asmf_add_inst(f, mk_inst(INST_JMP, 1,
				mk_oprd_label(f->break_tgt)
			));
			break;
		case STMT_RETURN: 
			gen_stmt_return(f, n);
			break;
	}
	return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl 0x8(%rsi), %eax
cmpq $0xd, %rax
ja 0x49a4
movq %rdi, %rbx
leaq 0x8b8f(%rip), %rcx      # 0xd4b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4bbd
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x4a1e
leaq 0x48(%rsp), %r14
jmp 0x496e
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4f21
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x4a27
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5240
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x45, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rsi), %rsi
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4173
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4a3e
movq 0x60(%rsi), %r14
testq %r14, %r14
je 0x49a4
cmpl $0x2, (%r14)
jne 0x49e8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4903
movq 0x60(%r14), %r14
jmp 0x49d2
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4e1e
leaq 0x8bbd(%rip), %rsi      # 0xd5c1
jmp 0x4a2e
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4e9d
leaq 0x8bcd(%rip), %rsi      # 0xd5e9
jmp 0x4a2e
leaq 0x8bf1(%rip), %rsi      # 0xd616
jmp 0x4a2e
leaq 0x8c04(%rip), %rsi      # 0xd632
xorl %edi, %edi
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/gen.c
// Function: gen_stmt_if
void gen_stmt_if(asm_f *f, ast_n *n) {
	//Jump to end if not true
	char *lbl_end = gen_numlabel(f);
	gen_expr(f, n->dat.stmt.expr);
	asmf_add_inst(f, mk_inst(INST_TEST, 2,
		mk_oprd(OPRD_REG, RAX),
		mk_oprd(OPRD_REG, RAX)
	));
	asmf_add_inst(f, mk_inst(INST_JZ, 1, mk_oprd_label(lbl_end)));

	//Generate if body
	if (n->dat.stmt.body != NULL)
		gen_stmt(f, n->dat.stmt.body);

	//Generate else body
	if (n->dat.stmt.else_body != NULL) {
		//The main if will jump to here if the expression was false
		//Otherwise, jump past the else block
		char *lbl_else_end = gen_numlabel(f);
		asmf_add_inst(f, mk_inst(INST_JMP, 1,
			mk_oprd_label(lbl_else_end)
		));
		asmf_add_inst(f, mk_label(lbl_end));
		lbl_end = lbl_else_end;

		gen_stmt(f, n->dat.stmt.else_body);
	}
	asmf_add_inst(f, mk_label(lbl_end));
	
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3e08
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x4173
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
leaq 0x80(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5220
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x3d, %edi
movl $0x2, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5240
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x39, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x4b25
movq %rbx, %rdi
callq 0x4903
cmpq $0x0, 0x28(%r14)
je 0x4b98
movq %rbx, %rdi
callq 0x3e08
movq %rax, %r12
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x5240
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x45, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x5255
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
movq %r15, %rdi
callq 0x5334
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x4903
movq %r12, %r15
movq %r15, %rdi
callq 0x5334
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5543
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq