LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/9-File/endian.c
// Function: main
int main(void) 	{
	unsigned long temp = 0x89ABCDEF;
	int i;
	unsigned char *ptr = (unsigned char *) &temp;

	if(ptr[0] == 0xef) {
		printf("This CPU is little endian, i.e., ending value in small (little) address\n");
	}
	else {
		printf("This CPU is big endian, i.e., ending value in big address\n");
	}

	printf("Byte-by-byte printing:\t");
	for(i = 0; i < sizeof(unsigned long); i++)
		printf("%x", ptr[i]);
	printf("\n");

	printf("Printing by value:\t");
	printf("%lx\n", temp);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x89abcdef, %eax       # imm = 0x89ABCDEF
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xef, %eax
jne 0x117e
leaq 0xe8f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x118c
leaq 0xec8(%rip), %rdi       # 0x204d
movb $0x0, %al
callq 0x1030
leaq 0xef5(%rip), %rdi       # 0x2088
movb $0x0, %al
callq 0x1030
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x8, %rax
jae 0x11d0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0xee2(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11a1
leaq 0xe74(%rip), %rdi       # 0x204b
movb $0x0, %al
callq 0x1030
leaq 0xebe(%rip), %rdi       # 0x20a3
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rsi
leaq 0xec0(%rip), %rdi       # 0x20b7
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/cd.c
// Function: main
int main(int argc, char **argv)
{
	if(argc == 1)
	{
		chdir("~");
		return 0;
	}
	else if(argc > 2)
	{
		puts("this is simplest implemention");
		return 0;
	}
	chdir(argv[1]);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1181
leaq 0xe91(%rip), %rdi       # 0x2004
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x11ab
cmpl $0x2, -0x8(%rbp)
jle 0x119c
leaq 0xe78(%rip), %rdi       # 0x2006
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x11ab
jmp 0x119e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/cat.c
// Function: show
void show(char path[PATH_MAX])
{
	int c;
	FILE *fp;
	fp = fopen(path, "r");
	if(fp == NULL) {
      		perror("Error in opening file");
   	} do {
      		c = fgetc(fp);
      		if( feof(fp) ) {
         		break ;
      		}
      		printf("%c", c);
   	} while(1);
	fclose(fp);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe5d(%rip), %rsi       # 0x2004
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11c3
leaq 0xe48(%rip), %rdi       # 0x2006
callq 0x1080
jmp 0x11c5
movq -0x18(%rbp), %rdi
callq 0x1050
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
je 0x11e1
jmp 0x11fa
movl -0xc(%rbp), %esi
leaq 0xe31(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1040
movb $0x1, %al
testb $0x1, %al
jne 0x11c5
jmp 0x11fa
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/cat.c
// Function: main
int main(int argc, char **argv)
{
	if(argc == 1)
	{
		printf("what the f#@& :/");
		return 0;
	}
	else if(argc > 2){
		printf("remember the simplicity");
		return 0;
	}

	show(argv[1]);	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1243
leaq 0xdec(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x1276
cmpl $0x2, -0x8(%rbp)
jle 0x1260
leaq 0xde0(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x1276
jmp 0x1262
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lesgourg[P]class_public/build/../source/input.c
// Function: input_needs_shooting_for_target
int input_needs_shooting_for_target(struct file_content * pfc,
                                    enum target_names target_name,
                                    double target_value,
                                    int * needs_shooting,
                                    ErrorMsg errmsg){

  *needs_shooting = _TRUE_;
  switch (target_name){
  case Omega_dcdmdr:
  case omega_dcdmdr:
  case Omega_scf:
  case Omega_ini_dcdm:
  case omega_ini_dcdm:
    /* Check that Omega's or omega's are nonzero: */
    if (target_value == 0.)
      *needs_shooting = _FALSE_;
    break;
  default:
    /* Default is no additional checks */
    *needs_shooting = _TRUE_;
    break;
  }

  return _SUCCESS_;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movsd %xmm0, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl $0x1, (%rax)
movl -0xc(%rsp), %eax
addl $-0x3, %eax
subl $0x4, %eax
ja 0x6c820
jmp 0x6c802
movsd -0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6c81e
jp 0x6c81e
movq -0x20(%rsp), %rax
movl $0x0, (%rax)
jmp 0x6c82b
movq -0x20(%rsp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lesgourg[P]class_public/build/../source/primordial.c
// Function: primordial_analytic_spectrum
int primordial_analytic_spectrum(
                                 struct primordial * ppm,
                                 int index_md,
                                 int index_ic1_ic2,
                                 double k,
                                 double * pk
                                 ) {

  if (ppm->is_non_zero[index_md][index_ic1_ic2] == _TRUE_) {
    *pk = ppm->amplitude[index_md][index_ic1_ic2]
      *exp((ppm->tilt[index_md][index_ic1_ic2]-1.)*log(k/ppm->k_pivot)
           + 0.5 * ppm->running[index_md][index_ic1_ic2] * pow(log(k/ppm->k_pivot), 2.));

  }
  else {
    *pk = 0.;
  }

  return _SUCCESS_;

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x2b0(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x38(%rsp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x1, %eax
jne 0xf737f
movq 0x40(%rsp), %rax
movq 0x2b8(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x2c0(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xbff79(%rip), %xmm1    # 0x1b7248
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rax
divsd (%rax), %xmm0
callq 0x82f0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x2c8(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x38(%rsp), %rcx
movsd 0xc0973(%rip), %xmm0    # 0x1b7c88
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rax
divsd (%rax), %xmm0
callq 0x82f0
movsd 0xc0944(%rip), %xmm1    # 0x1b7c80
callq 0x8610
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0xf738b
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/X1319RAY[P]fileIO/fscanf.c
// Function: main
int main(int argc, char* argv[]){
	
	// コマンドライン引数のチェック
	if(argc != 2){
		fprintf(stderr, "引数の数が間違っています．\n");
		fprintf(stderr, "./fgets input.txt\n");
		return 1;
	}
	
	// C言語のファイル入力のための準備
	FILE* fp; // FILE型構造体
	// 読み込みモードでファイルを開く
	fp = fopen(argv[1], "r"); // 失敗するとNULLを返す
	// ファイルを開くのに失敗したときの処理
	if(fp == NULL){
		fprintf(stderr, "Error: file not opened.\n");
		return 1;
	}
	
	// fscanf()で書式指定で1行ずつ読み込む
	char tmp[BUFSIZE];
	int num;
	int sum = 0;
	while(fscanf(fp, "%s %d", tmp, &num) != EOF){
		// ここでtmpを煮るなり焼くなりする
		printf("%s %d\n", tmp, num); // そのまま出力
		// 値をsumに加算
		sum += num;
	}
	
	printf("\nsum: %d\n", sum);
	
	// ファイルを閉じる
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x11db
movq 0x2e52(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe54(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
movq 0x2e3a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe65(%rip), %rsi       # 0x202d
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x12a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe56(%rip), %rsi       # 0x2040
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x121e
movq 0x2df7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe37(%rip), %rsi       # 0x2042
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x12a0
movl $0x0, -0x428(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rdx
leaq 0xe21(%rip), %rsi       # 0x205b
leaq -0x424(%rbp), %rcx
movb $0x0, %al
callq 0x1030
cmpl $-0x1, %eax
je 0x127c
leaq -0x420(%rbp), %rsi
movl -0x424(%rbp), %edx
leaq 0xe00(%rip), %rdi       # 0x2061
movb $0x0, %al
callq 0x1050
movl -0x424(%rbp), %eax
addl -0x428(%rbp), %eax
movl %eax, -0x428(%rbp)
jmp 0x1228
movl -0x428(%rbp), %esi
leaq 0xddf(%rip), %rdi       # 0x2068
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape120/ref/primate.cpp
// Function: MixColumnsInv(unsigned char*)
void MixColumnsInv(unsigned char *state) //Inverse MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			tmp[i]=T2(state[i])^T15(state[NumberColumns*1+i])^T9(state[NumberColumns*2+i])^T9(state[NumberColumns*3+i])^T15(state[NumberColumns*4+i])^T2(state[NumberColumns*5+i])^state[NumberColumns*6+i];
 			for(int j=1; j<NumberRows; j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j-1)+i];
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x7, 0x2c(%rsp)
jge 0x44e4
movl $0x0, 0x28(%rsp)
cmpl $0x8, 0x28(%rsp)
jge 0x44a0
movq 0x70(%rsp), %rax
movslq 0x28(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x20b0
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x2160
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x21a0
movb %al, %cl
movl 0x10(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x21a0
movb %al, %cl
movl 0x14(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x2160
movb %al, %cl
movl 0x18(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x1c(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x28, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x20b0
movb %al, %cl
movl 0x1c(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movq 0x70(%rsp), %rcx
movl 0x28(%rsp), %edx
addl $0x30, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %cl
movslq 0x28(%rsp), %rax
movb %cl, 0x30(%rsp,%rax)
movl $0x1, 0x24(%rsp)
cmpl $0x7, 0x24(%rsp)
jge 0x448e
movq 0x70(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
shll $0x3, %ecx
addl 0x28(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl 0x24(%rsp), %eax
shll $0x3, %eax
addl 0x28(%rsp), %eax
cltq
movb %cl, 0x30(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4450
jmp 0x4490
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4344
movl $0x0, 0x20(%rsp)
cmpl $0x38, 0x20(%rsp)
jge 0x44d2
movslq 0x20(%rsp), %rax
movb 0x30(%rsp,%rax), %dl
movq 0x70(%rsp), %rax
movslq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x44a8
jmp 0x44d4
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x4331
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhoudian64[P]OS2-exp/receiver.c
// Function: main
int main() {
	char buf[20];
	close(0);
	open("./mypipe.txt", O_RDWR);
	while(1) {
		scanf("%s",buf);
		printf("recive %s\n", buf);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
callq 0x1040
leaq 0xe77(%rip), %rdi       # 0x2004
movl $0x2, %esi
movb $0x0, %al
callq 0x1050
leaq -0x20(%rbp), %rsi
leaq 0xe6d(%rip), %rdi       # 0x2011
movb $0x0, %al
callq 0x1060
leaq -0x20(%rbp), %rsi
leaq 0xe5e(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
jmp 0x1199
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_02/print.c
// Function: main
int main(int argc, char *argv[])
{
  if (!parse_arg_list(argc, argv))
  {
    puts("Error: invalid arguments.");
    return EXIT_FAILURE;
  }

  int c;
  size_t col_pos = 1;
  while ((c = getc(stdin)) != EOF)
  {
    if (is_ascii(c))
    {
      if (c == '\n')
      {
        c = ' ';
      }

      putc(c, stdout);
      ++col_pos;
    }
    else
    {
      if (octal)
      {
        col_pos += printf("\\%o", c) - 1;
      }
      else
      {
        col_pos += printf("\\%x", c) - 1;
      }
    }

    if (col_pos >= MAX_LINE_LEN - OFFSET)
    {
      if (isblank(c))
      {
        col_pos = 1;
        putc('\n', stdout);
      }
    }
  }
  putc('\n', stdout);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12e0
cmpl $0x0, %eax
jne 0x11cf
leaq 0xe46(%rip), %rdi       # 0x2004
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x12d2
movq $0x1, -0x20(%rbp)
movq 0x2e02(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1070
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x12b7
movl -0x14(%rbp), %edi
callq 0x1370
cmpl $0x0, %eax
je 0x122c
cmpl $0xa, -0x14(%rbp)
jne 0x120c
movl $0x20, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq 0x2dc2(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1050
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1275
cmpl $0x0, 0x2e25(%rip)      # 0x4058
je 0x1255
movl -0x14(%rbp), %esi
leaq 0xddf(%rip), %rdi       # 0x201e
movb $0x0, %al
callq 0x1040
subl $0x1, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1273
movl -0x14(%rbp), %esi
leaq 0xdc3(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1040
subl $0x1, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1275
cmpq $0x46, -0x20(%rbp)
jb 0x12b2
callq 0x1080
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12b0
movq $0x1, -0x20(%rbp)
movq 0x2d35(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1050
jmp 0x12b2
jmp 0x11d7
movq 0x2d1a(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_02/print.c
// Function: parse_arg_list
boolean parse_arg_list(int argc, char *argv[])
{
  if (argc == 2)
  {
    if (strcmp(argv[1], "-o") == 0)
    {
      octal = true;
      return true;
    }
    else if (strcmp(argv[1], "-x") == 0)
    {
      octal = false;
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x1351
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd22(%rip), %rsi       # 0x2026
callq 0x1060
cmpl $0x0, %eax
jne 0x1321
movl $0x1, 0x2d40(%rip)      # 0x4058
movl $0x1, -0x4(%rbp)
jmp 0x1358
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xcf9(%rip), %rsi       # 0x2029
callq 0x1060
cmpl $0x0, %eax
jne 0x134d
movl $0x0, 0x2d14(%rip)      # 0x4058
movl $0x1, -0x4(%rbp)
jmp 0x1358
jmp 0x134f
jmp 0x1351
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfsdisplay.c
// Function: main
int main(int argc, char * * argv)
{
	FILE * f;

	if(argc < 2) {
		fprintf(stderr, "usage: %s <file.iso>\n", argv[0]);
		return 1;
	}
	f = fopen(argv[1], "rb");
	if(!f) {
		fprintf(stderr, "Failed to open file %s\n", argv[1]);
		return 2;
	}
	read_partition_map(f);
	if(hfs_part_sector == 0 && hfs_part_sector_count == 0) {
		printf("HFS/HFS+ partition not found\n");
	} else {
		read_hfs_volume_header(f);
		read_catalog(f);
	}
	fclose(f);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1287
movq 0x4d95(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2d90(%rip), %rsi      # 0x4004
movb $0x0, %al
callq 0x10c0
movl $0x1, -0x4(%rbp)
jmp 0x1322
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2d84(%rip), %rsi      # 0x401a
callq 0x1100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12cf
movq 0x4d4b(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x2d5e(%rip), %rsi      # 0x401d
movb $0x0, %al
callq 0x10c0
movl $0x2, -0x4(%rbp)
jmp 0x1322
movq -0x18(%rbp), %rdi
callq 0x3020
leaq 0x4dd5(%rip), %rax      # 0x60b4
cmpl $0x0, (%rax)
jne 0x1300
leaq 0x4dcd(%rip), %rax      # 0x60b8
cmpl $0x0, (%rax)
jne 0x1300
leaq 0x2d3e(%rip), %rdi      # 0x4035
movb $0x0, %al
callq 0x1080
jmp 0x1312
movq -0x18(%rbp), %rdi
callq 0x14f0
movq -0x18(%rbp), %rdi
callq 0x2ee0
movq -0x18(%rbp), %rdi
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/tt.c
// Function: interrupt_handler
static void interrupt_handler( int signum ) {
	signal( signum, interrupt_handler );
	env.interrupted = 1;
	if( env.worker ) {
		/* Terminate current worker. */
		( ( struct worker * ) env.worker )->env.interrupted = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x15(%rip), %rsi       # 0x3740
callq 0x3180
movb $0x1, 0x1ec5f(%rip)     # 0x223c0
cmpq $0x0, 0x1efdf(%rip)     # 0x22748
je 0x3776
movq 0x1efd6(%rip), %rax     # 0x22748
movb $0x1, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_element
struct element* new_element( int str_len ) {
	struct element *elem = malloc( sizeof( struct element ) + sizeof( char ) * ( str_len + 1 ) );
	if( elem ) {
		memset( elem, 0, sizeof( struct element ) );
		elem->str.string = ( char * ) &elem[ 1 ];
		elem->str.string[ str_len ] = 0;
		elem->str.reference_count = 1;
		elem->str.length = str_len;
		elem->str.type = ELEMENT;
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x30, %rdi
callq 0x31a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37f9
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x30f0
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_array
struct array* new_array( struct environment *env, int length, int str_len ) {
	size_t refs_size = length * sizeof( struct string * );
	size_t nums_size = length * sizeof( number );
	struct array *arr = calloc( 1, sizeof( struct array ) + refs_size + nums_size + str_len + 1 );
	if( arr ) {
		arr->string_values = ( struct string ** ) &arr[ 1 ];
		arr->number_values = ( number * ) &arr->string_values[ length ];
		arr->str.string = ( char * ) &arr->number_values[ length ];
		arr->str.length = str_len;
		arr->str.reference_count = 1;
		arr->str.type = ARRAY;
		arr->length = length;
		arr->prev = &env->arrays;
		arr->next = env->arrays.next;
		if( arr->next ) {
			arr->next->prev = arr;
		} 
		env->arrays.next = arr;
	}
	return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
addq -0x20(%rbp), %rsi
movslq -0x10(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x3120
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x391e
movq -0x28(%rbp), %rcx
addq $0x48, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x1, (%rax)
movq -0x28(%rbp), %rax
movb $0x2, 0x14(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x3912
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_source
struct source* new_source( int str_len ) {
	struct source *src = malloc( sizeof( struct source ) + sizeof( char ) * ( str_len + 1 ) );
	if( src ) {
		memset( src, 0, sizeof( struct source ) );
		src->str.string = ( char * ) &src[ 1 ];
		src->str.reference_count = 1;
		src->str.length = str_len;
		src->str.type = SOURCE;
	}
	return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x20, %rdi
callq 0x31a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3999
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x30f0
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x8, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_string
struct string* new_string( int length ) {
	struct string *str = malloc( sizeof( struct string ) + sizeof( char ) * ( length + 1 ) );
	if( str ) {
		memset( str, 0, sizeof( struct string ) );
		str->string = ( char * ) &str[ 1 ];
		str->string[ length ] = 0;
		str->reference_count = 1;
		str->length = length;
	}
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x18, %rdi
callq 0x31a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a21
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30f0
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_string_value
struct string* new_string_value( char *source ) {
	struct string *str = new_string( strlen( source ) );
	if( str ) {
		strcpy( str->string, source );
	}
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movl %eax, %edi
callq 0x39b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a68
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3070
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: load_file
long load_file( char *file_name, char *buffer, long offset, long count, char *message ) {
	long length, remain = -1;
	FILE *input_file = fopen( file_name, "rb" );
	if( input_file != NULL ) {
		if( fseek( input_file, 0L, SEEK_END ) == 0 ) {
			length = ftell( input_file );
			if( length >= 0 ) {
				if( offset < 0 || offset > length ) {
					offset = length;
				}
				remain = length - offset;
				if( remain > 0 && buffer ) {
					if( count > remain ) {
						count = remain;
					}
					remain = fseek( input_file, offset, SEEK_SET );
					if( remain == 0 ) {
						clearerr( input_file );
						remain = fread( buffer, 1, count, input_file );
						if( ferror( input_file ) ) {
							remain = -1;
						}
					}
				}
			}
		}
		fclose( input_file );
	}
	if( remain < 0 ) {
		strncpy( message, strerror( errno ), 63 );
		message[ 63 ] = 0;
	}
	return remain;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $-0x1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x17b8c(%rip), %rsi     # 0x1b63b
callq 0x31c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3ba1
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x31b0
cmpl $0x0, %eax
jne 0x3b98
movq -0x40(%rbp), %rdi
callq 0x3150
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jl 0x3b96
cmpq $0x0, -0x18(%rbp)
jl 0x3b07
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x3b0f
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jle 0x3b94
cmpq $0x0, -0x10(%rbp)
je 0x3b94
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x3b3b
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x31b0
cltq
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3b92
movq -0x40(%rbp), %rdi
callq 0x3160
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl $0x1, %esi
callq 0x3090
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3080
cmpl $0x0, %eax
je 0x3b90
movq $-0x1, -0x38(%rbp)
jmp 0x3b92
jmp 0x3b94
jmp 0x3b96
jmp 0x3b98
movq -0x40(%rbp), %rdi
callq 0x30a0
cmpq $0x0, -0x38(%rbp)
jge 0x3bd5
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x3040
movl (%rax), %edi
callq 0x3210
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x3f, %edx
callq 0x3050
movq -0x28(%rbp), %rax
movb $0x0, 0x3f(%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_variable
void dispose_variable( struct variable *var ) {
	var->number_value = 0;
	if( var->string_value ) {
		unref_string( var->string_value );
		var->string_value = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3c1a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: unref_string
void unref_string( struct string *str ) {
	if( str->reference_count == 1 ) {
		switch( str->type ) {
			default:
			case STRING:
				free( str );
				break;
			case ELEMENT:
				dispose_element( ( struct element * ) str );
				break;
			case ARRAY:
				dispose_array( ( struct array * ) str );
				break;
			case STRUCT:
				dispose_structure( ( struct structure * ) str );
				break;
			case GLOBAL: case CONST:
				dispose_global_variable( ( struct global_variable * ) str );
				break;
			case FUNCTION:
				dispose_function( ( struct function * ) str );
				break;
			case SOURCE:
				dispose_source( ( struct source * ) str );
				break;
			case CUSTOM:
				( ( struct custom * ) str )->type->dispose( str );
				break;
		}
	} else {
		str->reference_count--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x3cc4
movq -0x8(%rbp), %rax
movsbl 0x14(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x3c61
movq -0x10(%rbp), %rax
leaq 0x1743c(%rip), %rcx     # 0x1b094
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x3c63
movq -0x8(%rbp), %rdi
callq 0x3030
jmp 0x3cc2
movq -0x8(%rbp), %rdi
callq 0x3ed0
jmp 0x3cc2
movq -0x8(%rbp), %rdi
callq 0x3f50
jmp 0x3cc2
movq -0x8(%rbp), %rdi
callq 0x3fc0
jmp 0x3cc2
movq -0x8(%rbp), %rdi
callq 0x3ff0
jmp 0x3cc2
movq -0x8(%rbp), %rdi
callq 0x4040
jmp 0x3cc2
movq -0x8(%rbp), %rdi
callq 0x40b0
jmp 0x3cc2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x3cd2
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: assign_variable
void assign_variable( struct variable *src, struct variable *dest ) {
	if( dest->string_value ) {
		unref_string( dest->string_value );
	}
	dest->number_value = src->number_value;
	dest->string_value = src->string_value;
	if( dest->string_value ) {
		dest->string_value->reference_count++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d38
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d71
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_string_literal_expression
enum result evaluate_string_literal_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	result->number_value = ( ( struct value_expression * ) this )->num;
	result->string_value = ( ( struct value_expression * ) this )->str;
	result->string_value->reference_count++;
	return OKAY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_statements
void dispose_statements( struct statement *statements ) {
	struct statement *next;
	while( statements ) {
		next = statements->next;
		dispose_expressions( statements->source );
		if( statements->dispose ) {
			statements->dispose( statements );
		} else {
			free( statements );
		}
		statements = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e5a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e60
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3e47
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x3e50
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e0c
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_expressions
static void dispose_expressions( struct expression *expr ) {
	struct expression *next;
	while( expr ) {
		next = expr->next;
		dispose_expressions( expr->parameters );
		if( expr->evaluate == evaluate_string_literal_expression ) {
			unref_string( ( ( struct value_expression * ) expr )->str );
		}
		free( expr );
		expr = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ebd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e60
movq -0x8(%rbp), %rax
leaq -0xe7(%rip), %rcx       # 0x3db0
cmpq %rcx, 0x18(%rax)
jne 0x3eaa
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e6c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_element
static void dispose_element( struct element *elem ) {
	struct element *prev;
	while( elem ) {
		if( elem->str.reference_count == 1 ) {
			if( elem->child ) {
				dispose_element( elem->child );
			}
			prev = elem;
			elem = elem->next;
			free( prev );
		} else {
			elem->str.reference_count--;
			elem = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3f3c
movq -0x8(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x3f24
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3f05
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
jmp 0x3f3a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x3edc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_array
static void dispose_array( struct array *arr ) {
	truncate_array( arr );
	if( arr->prev ) {
		arr->prev->next = arr->next;
		if( arr->next ) {
			arr->next->prev = arr->prev;
		}
	}
	free( arr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa670
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3fa5
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x3fa3
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x30(%rax)
jmp 0x3fa5
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_global_variable
static void dispose_global_variable( struct global_variable *global ) {
	dispose_temporary( &global->value );
	if( global->init_function ) {
		unref_string( &global->init_function->str );
	}
	dispose_expressions( global->initializer );
	free( global );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x3ce0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4021
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3e60
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_function
static void dispose_function( struct function *func ) {
	if( func->file != &func->str ) {
		unref_string( func->file );
	}
	if( func->library ) {
		unref_string( func->library );
	}
	dispose_local_variables( func->variable_decls );
	dispose_statements( func->statements );
	free( func );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
je 0x406a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4082
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xa6f0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x3e00
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_environment
void dispose_environment( struct environment *env ) {
	int idx;
	for( idx = 0; idx < 32; idx++ ) {
		dispose_string_list( env->decls_index[ idx ] );
		dispose_keywords( env->statements_index[ idx ] );
		dispose_operators( env->operators_index[ idx ] );
	}
	dispose_string_list( env->globals );
	dispose_arrays( &env->arrays );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x4143
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rdi
callq 0x4170
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rdi
callq 0x41c0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x180(%rax,%rcx,8), %rdi
callq 0x4200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40f3
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rdi
callq 0x4170
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_string_list
static void dispose_string_list( struct string_list *list ) {
	struct string_list *next;
	while( list ) {
		next = list->next;
		unref_string( list->str );
		free( list );
		list = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3c20
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x417c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_keywords
static void dispose_keywords( struct keyword *keywords ) {
	struct keyword *next;
	while( keywords ) {
		next = keywords->next;
		free( keywords );
		keywords = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41f2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x41cc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_operators
static void dispose_operators( struct operator *operators ) {
	struct operator *next;
	while( operators ) {
		next = operators->next;
		free( operators );
		operators = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4232
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x420c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_arrays
static void dispose_arrays( struct array *head ) {
	struct array *arr = head->next;
	while( arr ) {
		arr->str.reference_count++;
		truncate_array( arr );
		arr = arr->next;
	}
	while( head->next ) {
		unref_string( &head->next->str );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4284
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xa670
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4258
jmp 0x4286
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x42a0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3c20
jmp 0x4286
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: throw_exit
enum result throw_exit( struct variables *vars, number exit_code, const char *message ) {
	struct variable *exception = vars->exception;
	struct environment *env = vars->func->env;
	env->exit.reference_count = 2;
	env->exit.type = EXIT;
	env->exit.string = ( char * ) message;
	dispose_temporary( exception );
	exception->number_value = exit_code;
	exception->string_value = &env->exit;
	return EXCEPTION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x2, 0x20(%rax)
movq -0x28(%rbp), %rax
movb $0xa, 0x34(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
callq 0x3ce0
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: throw
enum result throw( struct variables *vars, struct expression *source, number num, const char *string ) {
	struct variable *exception = vars->exception;
	struct array *arr = NULL;
	if( string ) {
		arr = stack_trace( source, vars, strlen( string ), 16 );
		if( arr ) {
			strcpy( arr->str.string, string );
		} else {
			return throw_exit( vars, 1, OUT_OF_MEMORY );
		}
	}
	dispose_temporary( exception );
	exception->number_value = num;
	exception->string_value = &arr->str;
	return EXCEPTION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x43c9
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
movl $0x10, %ecx
callq 0x4400
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x43ad
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x3070
jmp 0x43c7
movq -0x10(%rbp), %rdi
movq 0x1cda8(%rip), %rdx     # 0x21160
movl $0x1, %esi
callq 0x42b0
movl %eax, -0x4(%rbp)
jmp 0x43ee
jmp 0x43c9
movq -0x30(%rbp), %rdi
callq 0x3ce0
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: stack_trace
static struct array* stack_trace( struct expression *expr, struct variables *vars, int msg_len, int max_depth ) {
	struct array *arr = new_array( vars->func->env, max_depth, msg_len );
	int idx = 0, line = expr->line;
	if( arr ) {
		while( vars && vars->func && idx < max_depth ) {
			vars->func->str.reference_count++;
			arr->string_values[ idx ] = &vars->func->str;
			arr->number_values[ idx++ ] = line;
			line = vars->line;
			vars = vars->parent;
		}
		arr->length = idx;
	}
	return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x3810
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x44e9
jmp 0x444e
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x4476
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x29(%rbp)
je 0x4476
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x447f
jmp 0x44df
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x444e
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_decl
struct string_list* add_decl( struct string *decl, int line, struct environment *env, char *message ) {
	struct string_list *list = NULL;
	int hash = validate_decl( decl, line, env, message ) - 1;
	if( message[ 0 ] == 0 ) {
		list = new_string_list( decl, env->decls_index[ hash ] );
		if( list ) {
			env->decls_index[ hash ] = list;
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x47c0
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x47b1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rsi
callq 0x4850
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x479f
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, 0x280(%rax,%rcx,8)
jmp 0x47af
movq -0x20(%rbp), %rdi
movq 0x1c9b6(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0x47b1
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)