LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_close_open
void print_close_open(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_close_open(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2ba5
movq 0x10(%rsp), %rdi
callq 0x29b0
leaq 0x14c0(%rip), %rdi      # 0x4030
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2b96
leaq 0x14b9(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2b98
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2b55
leaq 0x149c(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_open_close
void print_open_close(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_open_close(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2c25
movq 0x10(%rsp), %rdi
callq 0x29d0
leaq 0x1440(%rip), %rdi      # 0x4030
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2c16
leaq 0x1439(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2c18
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2bd5
leaq 0x141c(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_open_open
void print_open_open(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_open_open(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2ca5
movq 0x10(%rsp), %rdi
callq 0x29f0
leaq 0x13c0(%rip), %rdi      # 0x4030
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2c96
leaq 0x13b9(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2c98
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2c55
leaq 0x139c(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread1
void *thread1(void *arg) {
	while(run == 1) {
		dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);

		c1++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x2424(%rip)      # 0x4098
jne 0x1cb4
leaq 0x248b(%rip), %rdi      # 0x4108
callq 0x1990
movq 0x2457(%rip), %rax      # 0x40e0
addq $0x1, %rax
movq %rax, 0x244c(%rip)      # 0x40e0
leaq 0x246d(%rip), %rdi      # 0x4108
callq 0x19e0
movq 0x2441(%rip), %rax      # 0x40e8
addq $0x1, %rax
movq %rax, 0x2436(%rip)      # 0x40e8
jmp 0x1c6c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread2
void *thread2(void *arg) {
	while(run == 1) {
        dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);
		c2++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x23c4(%rip)      # 0x4098
jne 0x1d14
leaq 0x242b(%rip), %rdi      # 0x4108
callq 0x1990
movq 0x23f7(%rip), %rax      # 0x40e0
addq $0x1, %rax
movq %rax, 0x23ec(%rip)      # 0x40e0
leaq 0x240d(%rip), %rdi      # 0x4108
callq 0x19e0
movq 0x23e9(%rip), %rax      # 0x40f0
addq $0x1, %rax
movq %rax, 0x23de(%rip)      # 0x40f0
jmp 0x1ccc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread3
void *thread3(void *arg) {
	while(run == 1) {
        dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);
		c3++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x2364(%rip)      # 0x4098
jne 0x1d74
leaq 0x23cb(%rip), %rdi      # 0x4108
callq 0x1990
movq 0x2397(%rip), %rax      # 0x40e0
addq $0x1, %rax
movq %rax, 0x238c(%rip)      # 0x40e0
leaq 0x23ad(%rip), %rdi      # 0x4108
callq 0x19e0
movq 0x2391(%rip), %rax      # 0x40f8
addq $0x1, %rax
movq %rax, 0x2386(%rip)      # 0x40f8
jmp 0x1d2c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread4
void *thread4(void *arg) {
	while(run == 1) {
        dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);
		c4++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x2304(%rip)      # 0x4098
jne 0x1dd4
leaq 0x236b(%rip), %rdi      # 0x4108
callq 0x1990
movq 0x2337(%rip), %rax      # 0x40e0
addq $0x1, %rax
movq %rax, 0x232c(%rip)      # 0x40e0
leaq 0x234d(%rip), %rdi      # 0x4108
callq 0x19e0
movq 0x2339(%rip), %rax      # 0x4100
addq $0x1, %rax
movq %rax, 0x232e(%rip)      # 0x4100
jmp 0x1d8c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: main
int main() {
	dthread_t th1, th2, th3, th4; 
    dthread_init();
	dthread_spin_init(&lock);
    printf("\n\n");

	dthread_create(&th1, thread1, NULL);
	dthread_create(&th2, thread2, NULL);
	dthread_create(&th3, thread3, NULL);
	dthread_create(&th4, thread4, NULL);

	for(int i = 0; i < 100000000; i++);
	run = 0;
	dthread_join(th1, NULL);
	dthread_join(th2, NULL);
	dthread_join(th3, NULL);
	dthread_join(th4, NULL);


	if(c == c1 + c2 + c3 + c4) {
		printf(GREEN "**PASSED**: Spin lock test for race problem between 4 threads\n" NONE);
	}
	else {
		printf(RED "**FAILED**: Spin lock test for race problem between 4 threads\n" NONE);
	}
    // printf("\n%ld %ld %ld %ld %ld %ld\n", c, c1+c2+c3+c4 , c1, c2, c3, c4);

	
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1210
leaq 0x230d(%rip), %rdi      # 0x4108
callq 0x1970
leaq 0x22a(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1070
leaq -0x10(%rbp), %rdi
leaq -0x1b9(%rip), %rsi      # 0x1c60
xorl %eax, %eax
movl %eax, %edx
callq 0x1630
leaq -0x18(%rbp), %rdi
leaq -0x16d(%rip), %rsi      # 0x1cc0
xorl %eax, %eax
movl %eax, %edx
callq 0x1630
leaq -0x20(%rbp), %rdi
leaq -0x121(%rip), %rsi      # 0x1d20
xorl %eax, %eax
movl %eax, %edx
callq 0x1630
leaq -0x28(%rbp), %rdi
leaq -0xd5(%rip), %rsi       # 0x1d80
xorl %eax, %eax
movl %eax, %edx
callq 0x1630
movl $0x0, -0x2c(%rbp)
cmpl $0x5f5e100, -0x2c(%rbp) # imm = 0x5F5E100
jge 0x1e7b
jmp 0x1e70
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1e65
movq $0x0, 0x2212(%rip) # 0x4098
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17f0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17f0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17f0
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17f0
movq 0x221f(%rip), %rax      # 0x40e0
movq 0x2220(%rip), %rcx      # 0x40e8
addq 0x2221(%rip), %rcx      # 0x40f0
addq 0x2222(%rip), %rcx      # 0x40f8
addq 0x2223(%rip), %rcx      # 0x4100
cmpq %rcx, %rax
jne 0x1ef2
leaq 0x14b(%rip), %rdi       # 0x2034
movb $0x0, %al
callq 0x1070
jmp 0x1f00
leaq 0x187(%rip), %rdi       # 0x2080
movb $0x0, %al
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/mv.c
// Function: main
int
main(int argc, char **argv)
{
	int c;
	FILE *fp;
	FILE *dest;

	fp = fopen(argv[1], "r");
	dest = fopen(argv[2], "w");
	if(fp == NULL) {
                perror("Error in opening file");
        } do {
                c = fgetc(fp);
                if( feof(fp) ) {
                        break ;
                }
                fputc(c, dest);
        } while(1);
        fclose(fp);
	int delete = remove(argv[1]);
	if (!delete)
		return 0;
	else
		printf("permission denied ! \n");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe2f(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xe19(%rip), %rsi       # 0x2006
callq 0x1090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1209
leaq 0xe04(%rip), %rdi       # 0x2008
callq 0x10a0
jmp 0x120b
movq -0x20(%rbp), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x1227
jmp 0x123b
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x1070
movb $0x1, %al
testb $0x1, %al
jne 0x120b
jmp 0x123b
movq -0x20(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x1263
movl $0x0, -0x4(%rbp)
jmp 0x1271
leaq 0xdb4(%rip), %rdi       # 0x201e
movb $0x0, %al
callq 0x1050
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpc_state_invalid
static mpc_state_t mpc_state_invalid(void) {
  mpc_state_t s;
  s.pos = -1;
  s.row = -1;
  s.col = -1;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq $-0x1, (%rdi)
movq $-0x1, 0x8(%rdi)
movq $-0x1, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpc_err_file
static mpc_err_t *mpc_err_file(const char *filename, const char *failure) {
  mpc_err_t *x;
  x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = mpc_state_new();
  x->expected_num = 0;
  x->expected = NULL;
  x->failure = malloc(strlen(failure) + 1);
  strcpy(x->failure, failure);
  x->recieved = ' ';
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x40, %edi
callq 0x2190
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2190
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8340
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2190
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rax
movb $0x20, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcf_re_repeat
static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
  int num;
  (void) n;
  if (xs[1] == NULL) { return xs[0]; }
  if (strcmp(xs[1], "*") == 0) { free(xs[1]); return mpc_many(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "+") == 0) { free(xs[1]); return mpc_many1(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "?") == 0) { free(xs[1]); return mpc_maybe_lift(xs[0], mpcf_ctor_str); }
  num = *(int*)xs[1];
  free(xs[1]);
  
  return mpc_count(num, mpcf_strfold, xs[0], free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6c0a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d05
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x13a5a(%rip), %rsi     # 0x1a673
callq 0x2130
cmpl $0x0, %eax
jne 0x6c4c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x13fe(%rip), %rdi     # 0x5840
callq 0x5190
movq %rax, -0x8(%rbp)
jmp 0x6d05
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x13a1c(%rip), %rsi     # 0x1a677
callq 0x2130
cmpl $0x0, %eax
jne 0x6c8b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x1440(%rip), %rdi     # 0x5840
callq 0x51e0
movq %rax, -0x8(%rbp)
jmp 0x6d05
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x13a0b(%rip), %rsi     # 0x1a6a5
callq 0x2130
cmpl $0x0, %eax
jne 0x6cca
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0xd8f(%rip), %rsi      # 0x5f30
callq 0x5110
movq %rax, -0x8(%rbp)
jmp 0x6d05
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq -0x14b5(%rip), %rsi     # 0x5840
movq 0x1a2b4(%rip), %rcx     # 0x20fb0
callq 0x5230
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcf_re_escape
static mpc_val_t *mpcf_re_escape(mpc_val_t *x) {
  
  char *s = x;
  mpc_parser_t *p;
  
  /* Regex Special Characters */
  if (s[0] == '.') { free(s); return mpc_any(); }
  if (s[0] == '^') { free(s); return mpc_and(2, mpcf_snd, mpc_soi(), mpc_lift(mpcf_ctor_str), free); }
  if (s[0] == '$') { free(s); return mpc_and(2, mpcf_snd, mpc_eoi(), mpc_lift(mpcf_ctor_str), free); }
  
  /* Regex Escape */
  if (s[0] == '\\') {
    p = mpc_re_escape_char(s[1]);
    p = (p == NULL) ? mpc_char(s[1]) : p;
    free(s);
    return p;
  }
  
  /* Regex Standard */
  p = mpc_char(s[0]);
  free(s);
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x6d47
movq -0x18(%rbp), %rdi
callq 0x2280
callq 0x4d00
movq %rax, -0x8(%rbp)
jmp 0x6e67
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x6d9b
movq -0x18(%rbp), %rdi
callq 0x2280
callq 0x5610
movq %rax, -0x28(%rbp)
leaq -0xe3c(%rip), %rdi      # 0x5f30
callq 0x4ae0
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq -0xb34(%rip), %rsi      # 0x6250
movq 0x1a225(%rip), %r8      # 0x20fb0
movb $0x0, %al
callq 0x53f0
movq %rax, -0x8(%rbp)
jmp 0x6e67
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x6dec
movq -0x18(%rbp), %rdi
callq 0x2280
callq 0x5670
movq %rax, -0x30(%rbp)
leaq -0xe90(%rip), %rdi      # 0x5f30
callq 0x4ae0
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq -0xb88(%rip), %rsi      # 0x6250
movq 0x1a1d1(%rip), %r8      # 0x20fb0
movb $0x0, %al
callq 0x53f0
movq %rax, -0x8(%rbp)
jmp 0x6e67
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x6e46
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0xd3e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6e23
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x4d30
movq %rax, -0x38(%rbp)
jmp 0x6e2b
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2280
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e67
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x4d30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2280
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcf_strtriml
mpc_val_t *mpcf_strtriml(mpc_val_t *x) {
  char *s = x;
  while (isspace(*s)) {
    memmove(s, s+1, strlen(s));
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x2270
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x7333
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x72e4
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcf_strtrimr
mpc_val_t *mpcf_strtrimr(mpc_val_t *x) {
  char *s = x;
  size_t l = strlen(s);
  while (isspace(s[l-1])) {
    s[l-1] = '\0'; l--;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x18(%rbp)
callq 0x2270
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x73a8
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7361
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcf_maths
mpc_val_t *mpcf_maths(int n, mpc_val_t **xs) {
  int **vs = (int**)xs;
  (void) n;
  
  if (strcmp(xs[1], "*") == 0) { *vs[0] *= *vs[2]; }
  if (strcmp(xs[1], "/") == 0) { *vs[0] /= *vs[2]; }
  if (strcmp(xs[1], "%") == 0) { *vs[0] %= *vs[2]; }
  if (strcmp(xs[1], "+") == 0) { *vs[0] += *vs[2]; }
  if (strcmp(xs[1], "-") == 0) { *vs[0] -= *vs[2]; }
  
  free(xs[1]); free(xs[2]);
  
  return xs[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x12cad(%rip), %rsi     # 0x1a673
callq 0x2130
cmpl $0x0, %eax
jne 0x79e6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x12e38(%rip), %rsi     # 0x1a82d
callq 0x2130
cmpl $0x0, %eax
jne 0x7a21
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x12c45(%rip), %rsi     # 0x1a675
callq 0x2130
cmpl $0x0, %eax
jne 0x7a5a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x12c0e(%rip), %rsi     # 0x1a677
callq 0x2130
cmpl $0x0, %eax
jne 0x7a88
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x12b7b(%rip), %rsi     # 0x1a612
callq 0x2130
cmpl $0x0, %eax
jne 0x7ab8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2280
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpc_state_new
static mpc_state_t mpc_state_new(void) {
  mpc_state_t s;
  s.pos = 0;
  s.row = 0;
  s.col = 0;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcaf_grammar_repeat
static mpc_val_t *mpcaf_grammar_repeat(int n, mpc_val_t **xs) { 
  int num;
  (void) n;
  if (xs[1] == NULL) { return xs[0]; }  
  if (strcmp(xs[1], "*") == 0) { free(xs[1]); return mpca_many(xs[0]); }
  if (strcmp(xs[1], "+") == 0) { free(xs[1]); return mpca_many1(xs[0]); }
  if (strcmp(xs[1], "?") == 0) { free(xs[1]); return mpca_maybe(xs[0]); }
  if (strcmp(xs[1], "!") == 0) { free(xs[1]); return mpca_not(xs[0]); }
  num = *((int*)xs[1]);
  free(xs[1]);
  return mpca_count(num, xs[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x97ea
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x98fd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x10e7a(%rip), %rsi     # 0x1a673
callq 0x2130
cmpl $0x0, %eax
jne 0x9825
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8ef0
movq %rax, -0x8(%rbp)
jmp 0x98fd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x10e43(%rip), %rsi     # 0x1a677
callq 0x2130
cmpl $0x0, %eax
jne 0x9860
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8f20
movq %rax, -0x8(%rbp)
jmp 0x98fd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x10e36(%rip), %rsi     # 0x1a6a5
callq 0x2130
cmpl $0x0, %eax
jne 0x9898
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8ed0
movq %rax, -0x8(%rbp)
jmp 0x98fd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x11036(%rip), %rsi     # 0x1a8dd
callq 0x2130
cmpl $0x0, %eax
jne 0x98d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8ea0
movq %rax, -0x8(%rbp)
jmp 0x98fd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x8f50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpcaf_grammar_regex
static mpc_val_t *mpcaf_grammar_regex(mpc_val_t *x, void *s) {
  mpca_grammar_st_t *st = s;
  char *y = mpcf_unescape_regex(x);
  mpc_parser_t *p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_re(y) : mpc_tok(mpc_re(y));
  free(y);
  return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "regex"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7770
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x9a93
movq -0x20(%rbp), %rdi
callq 0x6770
movq %rax, -0x30(%rbp)
jmp 0x9aa8
movq -0x20(%rbp), %rdi
callq 0x6770
movq %rax, %rdi
callq 0x6430
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2280
movq -0x28(%rbp), %rdi
leaq -0xda4(%rip), %rsi      # 0x8d20
callq 0x4f80
movq %rax, %rdi
leaq 0x10b54(%rip), %rsi     # 0x1a627
callq 0x8e10
movq %rax, %rdi
callq 0x8dd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpc_input_unmark
static void mpc_input_unmark(mpc_input_t *i) {
  
  if (i->backtrack < 1) { return; }
  
  i->marks_num--;
  
  if (i->marks_slots > i->marks_num + i->marks_num / 2
  &&  i->marks_slots > MPC_INPUT_MARKS_MIN) {
    i->marks_slots = 
      i->marks_num > MPC_INPUT_MARKS_MIN ?
      i->marks_num : MPC_INPUT_MARKS_MIN;
    i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
    i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);      
  }
  
  if (i->type == MPC_INPUT_PIPE && i->marks_num == 0) {
    free(i->buffer);
    i->buffer = NULL;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jge 0xbe3b
jmp 0xbf1b
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movl -0xc(%rbp), %eax
addl %edx, %ecx
cmpl %ecx, %eax
jle 0xbeef
movq -0x8(%rbp), %rax
cmpl $0x20, 0x48(%rax)
jle 0xbeef
movq -0x8(%rbp), %rax
cmpl $0x20, 0x4c(%rax)
jle 0xbe93
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0xbe9d
movl $0x20, %eax
movl %eax, -0x10(%rbp)
jmp 0xbe9d
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x48(%rax), %rax
imulq $0x18, %rax, %rsi
callq 0x21c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x48(%rax), %rsi
shlq $0x0, %rsi
callq 0x21c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xbf1b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0xbf1b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2280
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpc_err_count
static mpc_err_t *mpc_err_count(mpc_input_t *i, mpc_err_t *x, int n) {
  mpc_err_t *y;
  int digits = n/10 + 1;
  char *prefix;
  prefix = mpc_malloc(i, digits + strlen(" of ") + 1);
  sprintf(prefix, "%i of ", n);
  y = mpc_err_repeat(i, x, prefix);
  mpc_free(i, prefix);
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
addq $0x4, %rsi
addq $0x1, %rsi
callq 0xb410
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0xe550(%rip), %rsi      # 0x1a79b
movb $0x0, %al
callq 0x2220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xcb70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc170
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/mpc.c
// Function: mpc_input_terminated
static int mpc_input_terminated(mpc_input_t *i) {
  if (i->type == MPC_INPUT_STRING && i->state.pos == (long)strlen(i->string)) { return 1; }
  if (i->type == MPC_INPUT_FILE && feof(i->file)) { return 1; }
  if (i->type == MPC_INPUT_PIPE && feof(i->file)) { return 1; }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc3a3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0xc3a3
movl $0x1, -0x4(%rbp)
jmp 0xc3f2
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xc3c7
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2150
cmpl $0x0, %eax
je 0xc3c7
movl $0x1, -0x4(%rbp)
jmp 0xc3f2
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc3eb
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2150
cmpl $0x0, %eax
je 0xc3eb
movl $0x1, -0x4(%rbp)
jmp 0xc3f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/kstring.c
// Function: kvsprintf
int kvsprintf(kstring_t *s, const char *fmt, va_list ap)
{
	va_list args;
	int l;
	va_copy(args, ap);
	l = vsnprintf(s->s + s->l, s->m - s->l, fmt, args); // This line does not work with glibc 2.0. See `man snprintf'.
	va_end(args);
	if (l + 1 > s->m - s->l) {
		s->m = s->l + l + 2;
		kroundup32(s->m);
		s->s = (char*)realloc(s->s, s->m);
		va_copy(args, ap);
		l = vsnprintf(s->s + s->l, s->m - s->l, fmt, args);
		va_end(args);
	}
	s->l += l;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
addq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
subq (%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2080
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movl -0x34(%rbp), %eax
addl $0x1, %eax
cltq
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
subq (%rdx), %rcx
cmpq %rcx, %rax
jbe 0xde45
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq -0x34(%rbp), %rax
addq %rax, %rcx
addq $0x2, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x21c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
addq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
subq (%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2080
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/slre.c
// Function: slre_match
int slre_match(const char *regexp, const char *s, int s_len,
               struct slre_cap *caps, int num_caps, int flags) {
  struct regex_info info;

  /* Initialize info structure */
  info.flags = flags;
  info.num_brackets = info.num_branches = 0;
  info.num_caps = num_caps;
  info.caps = caps;

  DBG(("========================> [%s] [%.*s]\n", regexp, s_len, s));
  return foo(regexp, (int) strlen(regexp), s, s_len, &info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xff0, %rsp            # imm = 0xFF0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x688(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xff0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movq -0xff0(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0xfe8(%rbp), %r8
callq 0xe9a0
addq $0xff0, %rsp            # imm = 0xFF0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/slre.c
// Function: baz
static int baz(const char *s, int s_len, struct regex_info *info) {
  int i, result = -1, is_anchored = info->brackets[0].ptr[0] == '^';

  for (i = 0; i <= s_len; i++) {
    result = doh(s + i, s_len - i, info, 0);
    if (result >= 0) {
      result += i;
      break;
    }
    if (is_anchored) break;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xf0c6
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
subl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0xf1a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xf0b1
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xf0c6
cmpl $0x0, -0x24(%rbp)
je 0xf0b9
jmp 0xf0c6
jmp 0xf0bb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf079
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/slre.c
// Function: set_len
static int set_len(const char *re, int re_len) {
  int len = 0;

  while (len < re_len && re[len] != ']') {
    len += op_len(re + len);
  }

  return len <= re_len ? len + 1 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x11(%rbp)
jge 0xf108
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xf111
jmp 0xf129
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
addq %rax, %rdi
callq 0xf150
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xf0e6
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xf13c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf146
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xf146
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/slre.c
// Function: doh
static int doh(const char *s, int s_len, struct regex_info *info, int bi) {
  const struct bracket_pair *b = &info->brackets[bi];
  int i = 0, len, result;
  const char *p;

  do {
    p = i == 0 ? b->ptr : info->branches[b->branches + i - 1].schlong + 1;
    len = b->num_branches == 0 ? b->len :
      i == b->num_branches ? (int) (b->ptr + b->len - p) :
      (int) (info->branches[b->branches + i].schlong - p);
    DBG(("%s %d %d [%.*s] [%.*s]\n", __func__, bi, i, len, p, s_len, s));
    result = bar(p, len, s, s_len, info, bi);
    DBG(("%s <- %d\n", __func__, result));
  } while (result <= 0 && i++ < b->num_branches);  /* At least 1 iteration */

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xf1e3
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xf210
movq -0x18(%rbp), %rax
addq $0x968, %rax            # imm = 0x968
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
addl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xf22e
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xf28a
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0xf258
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x50(%rbp)
jmp 0xf284
movq -0x18(%rbp), %rax
addq $0x968, %rax            # imm = 0x968
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
movl -0x1c(%rbp), %r9d
callq 0xf2f0
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x34(%rbp)
movb %al, -0x51(%rbp)
jg 0xf2d1
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
setl %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xf1d0
movl -0x34(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_value_env_from_context
ore_value
ore_value_env_from_context(ore_context* p) {
  ore_value v = { ORE_TYPE_ENV };
  v.v.e = (ore_env*) malloc(sizeof(ore_env));
  if (!v.v.e) {
    fprintf(stderr, "failed to allocate memory\n");
    p->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.e->ref = 0;
  v.v.e->p = p;
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0xa, -0x30(%rbp)
movl $0x10, %edi
callq 0x2190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1078e
movq 0x10891(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
leaq 0xa44d(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x107b6
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_prop
ore_value
ore_prop(ore_context* ore, const char* name) {
  ore_context* p = ore;
  if (!p)
    return ore_value_nil();
  khint_t k;
  k = kh_get(value, p->env, name);
  if (k != kh_end(p->env)) {
    return kh_value(p->env, k);
  }
  return ore_value_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10882
movq -0x30(%rbp), %rdi
callq 0x10670
jmp 0x108d1
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x108e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x108c8
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
movl -0x1c(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x2170
jmp 0x108d1
movq -0x30(%rbp), %rdi
callq 0x10670
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_get
ore_value
ore_get(ore_context* ore, const char* name) {
  ore_context* p = ore;
  if (!p)
    return ore_value_nil();
  khint_t k;
  while (p) {
    k = kh_get(value, p->env, name);
    if (k != kh_end(p->env)) {
      return kh_value(p->env, k);
    }
    p = p->parent;
  }
  fprintf(stderr, "unknown identifier '%s'\n", name);
  ore->err = ORE_ERROR_EXCEPTION;
  return ore_value_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10a65
movq -0x30(%rbp), %rdi
callq 0x10670
jmp 0x10af2
jmp 0x10a67
cmpq $0x0, -0x18(%rbp)
je 0x10ac2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x108e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x10ab4
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
movl -0x1c(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x2170
jmp 0x10af2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10a67
movq 0x1052f(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa102(%rip), %rsi      # 0x1abd9
movb $0x0, %al
callq 0x2140
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_set
void
ore_set(ore_context* ore, const char* name, ore_value v) {
  khint_t k;
  int r = 0;
  ore_value old = ore_value_nil();
  while (ore) {
    k = kh_get(value, ore->env, name);
    if (k != kh_end(ore->env)) {
      old = kh_value(ore->env, k);
      ore_value_ref(v);
      ore_value_unref(old);
      k = kh_put(value, ore->env, name, &r);
      kh_value(ore->env, k) = v;
      return;
    }
    if (ore->parent == NULL) {
      if (k != kh_end(ore->env)) 
        old = kh_value(ore->env, k);
      ore_value_ref(v);
      ore_value_unref(old);
      k = kh_put(value, ore->env, name, &r);
      kh_value(ore->env, k) = v;
      return;
    }
    ore = ore->parent;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10670
cmpq $0x0, -0x8(%rbp)
je 0x10cc9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x108e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x10bfb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
movl -0x14(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x2170
movq -0x48(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10250
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xffb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x10cd0
movq -0x48(%rbp), %rsi
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl $0x28, %edx
callq 0x2170
jmp 0x10cc9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x10cb8
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x10c3b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
movl -0x14(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x2170
movq -0x48(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10250
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xffb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x10cd0
movq -0x48(%rbp), %rsi
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl $0x28, %edx
callq 0x2170
jmp 0x10cc9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b28
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_define
void
ore_define(ore_context* ore, const char* name, ore_value v) {
  int r = 0;
  ore_value old = ore_value_nil();
  khint_t k = kh_get(value, ore->env, name);
  if (k != kh_end(ore->env))
    old = kh_value(ore->env, k);
  k = kh_put(value, ore->env, name, &r);
  ore_value_ref(v);
  kh_value(ore->env, k) = v;
  ore_value_unref(old);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10670
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x108e0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x1109f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
movl -0x44(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x2170
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x10cd0
movq -0x50(%rbp), %rcx
movl %eax, -0x44(%rbp)
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10250
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movl -0x44(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl $0x28, %edx
callq 0x2170
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xffb0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: orex_define_class
ore_value
orex_define_class(ore_context* ore, const char* name) {
  ore_value v = { ORE_TYPE_CCLASS };
  v.v.x = (ore_cclass*) malloc(sizeof(ore_cclass));
  if (!v.v.x) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.x->n = name;
  v.v.x->e = ore_new(ore);
  ore_context* g = ore;
  while (g->parent) g = g->parent;
  ore_define(g, v.v.x->n, v);
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0xc, -0x38(%rbp)
movl $0x10, %edi
callq 0x2190
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x111a5
movq 0xfe7a(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x9a36(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x11221
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x11230
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x111e5
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x111cc
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11030
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop