LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/sample.c
// Function: say_hello
BEH_DECL(say_hello)
{
	CONS* name = map_get(WHAT, ATOM("name"));
	CONS* printer = ACTOR(print_text, NIL);
	CONS* a_text = ATOM("text");

	DBUG_ENTER("say_hello");
	SEND(printer, map_put(NIL, a_text, ATOM("Hello, ")));
	SEND(printer, MINE);
	SEND(printer, map_put(NIL, a_text, ATOM(" from ")));
	SEND(ACTOR(print_line, NIL), map_put(NIL, a_text, name));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xb346
movq %rax, %r14
leaq 0xadda(%rip), %rdi      # 0xe29b
callq 0x895f
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xb7c7
movq %rax, %r14
leaq -0xad7(%rip), %rsi      # 0x2a06
leaq 0x10dac(%rip), %r15     # 0x14290
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43f7
movq %rax, %rbp
leaq 0xacc1(%rip), %rdi      # 0xe1ba
callq 0x895f
movq %rax, %r13
leaq 0xad98(%rip), %rax      # 0xe2a0
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x10e0a(%rip), %rax     # 0x14320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r12)
movl $0x9b, 0xc(%r12)
leaq 0xc953(%rip), %rcx      # 0xfe88
movq %rcx, 0x10(%r12)
leaq 0x10c47(%rip), %rcx     # 0x14188
movq %rcx, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %r12, %rdi
callq 0xd0b9
leaq 0xad50(%rip), %rdi      # 0xe2aa
callq 0x895f
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xb839
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x44d4
movq 0x30(%rbx), %rdi
callq 0xb23b
movq %rax, %rdi
callq 0x379b
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x44d4
leaq 0xad11(%rip), %rdi      # 0xe2b2
callq 0x895f
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xb839
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x44d4
leaq -0xb0c(%rip), %rsi      # 0x2abd
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43f7
movq %rax, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xb839
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x44d4
movl $0xa0, 0xc(%r12)
movq %r12, %rdi
callq 0xd232
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/sample.c
// Function: test_sample
void
test_sample(CONFIG* cfg)
{
	CONS* actor;
	CONS* state;
	CONS* msg;

	DBUG_ENTER("test_sample");
	TRACE(printf("--test_sample--\n"));
	state = map_put(NIL, ATOM("text"), ATOM("Actor"));
	actor = CFG_ACTOR(cfg, say_hello, state);
	
	msg = map_put(NIL, ATOM("name"), ATOM("World!"));
	CFG_SEND(cfg, actor, msg);
	
	msg = NIL;
	msg = map_put(msg, ATOM("name"), NUMBER(42));
	msg = map_put(msg, ATOM("addr"), actor);
	CFG_SEND(cfg, actor, msg);
	
	report_configuration(cfg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0xac8e(%rip), %rax      # 0xe2b9
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0x10ce8(%rip), %rax     # 0x14320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl $0xaa, 0xc(%rbx)
leaq 0xc835(%rip), %rcx      # 0xfe88
movq %rcx, 0x10(%rbx)
leaq 0x10b2a(%rip), %rcx     # 0x14188
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0xd0b9
leaq 0xac78(%rip), %rdi      # 0xe2ed
callq 0x20b0
leaq 0xab39(%rip), %rdi      # 0xe1ba
callq 0x895f
movq %rax, %r15
leaq 0xac35(%rip), %rdi      # 0xe2c5
callq 0x895f
leaq 0x10bf4(%rip), %r12     # 0x14290
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb839
leaq -0x214(%rip), %rsi      # 0x349d
movq %r14, %rdi
movq %rax, %rdx
callq 0x43f7
movq %rax, %r15
leaq 0xabd5(%rip), %r13      # 0xe29b
movq %r13, %rdi
callq 0x895f
movq %rax, %rbp
leaq 0xabf3(%rip), %rdi      # 0xe2cb
callq 0x895f
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xb839
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x44d4
movq %r13, %rdi
callq 0x895f
movl $0xab, %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0xb839
movq %rax, %r12
leaq 0xabb7(%rip), %rdi      # 0xe2d2
callq 0x895f
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xb839
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x44d4
movq %r14, %rdi
callq 0x529a
movl $0xb8, 0xc(%rbx)
movq %rbx, %rdi
callq 0xd232
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/7-Threading/pthread_hello_world.c
// Function: hello
void * hello(void *input)
{
	int i;

	for(i = 0; i < 100000000; i++)
	{
		if(i == 10000000)
			printf("T:DAM!\n");
		if(i == 50000000)
			printf("T:BAM!\n");
		if(i == 100000000-1)
			printf("T:GAM!\n");
	}

	printf("%s\n", (char *) input);
	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0xe90(%rip), %r14       # 0x2010
leaq 0xe90(%rip), %r15       # 0x2017
leaq 0xe90(%rip), %r12       # 0x201e
movq %r14, %rdi
cmpl $0x989680, %ebp         # imm = 0x989680
je 0x11bb
cmpl $0x2faf080, %ebp        # imm = 0x2FAF080
je 0x11b8
cmpl $0x5f5e0ff, %ebp        # imm = 0x5F5E0FF
je 0x11b3
cmpl $0x5f5e100, %ebp        # imm = 0x5F5E100
jne 0x11c0
jmp 0x11c4
movq %r12, %rdi
jmp 0x11bb
movq %r15, %rdi
callq 0x1030
incl %ebp
jmp 0x118e
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/7-Threading/pthread_hello_world.c
// Function: main
int main(void)
{
	int i;
	pthread_t tid;
	pthread_create(&tid, NULL, hello, "hello world");

	for(i = 0; i < 100000000; i++)
	{
		if(i == 10000000)
			printf("JAM\n");
		if(i == 50000000) 
			printf("EAM\n");
		if(i == 100000000-1)
			printf("ZAM\n");
	}

	pthread_join(tid, NULL);
	printf("main thread terminated\n");
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq -0x76(%rip), %rdx       # 0x116c
leaq 0xe1b(%rip), %rcx       # 0x2004
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1050
leaq 0xe40(%rip), %r14       # 0x203c
leaq 0xe3d(%rip), %r15       # 0x2040
leaq 0xe3a(%rip), %r12       # 0x2044
movq %r14, %rdi
cmpl $0x989680, %ebx         # imm = 0x989680
je 0x1237
cmpl $0x2faf080, %ebx        # imm = 0x2FAF080
je 0x122f
cmpl $0x5f5e0ff, %ebx        # imm = 0x5F5E0FF
je 0x1234
cmpl $0x5f5e100, %ebx        # imm = 0x5F5E100
jne 0x123c
jmp 0x1240
movq %r15, %rdi
jmp 0x1237
movq %r12, %rdi
callq 0x1030
incl %ebx
jmp 0x120a
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1060
leaq 0xdd3(%rip), %rdi       # 0x2025
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ikbenlike[P]nngutils/src/yes.c
// Function: main
int main(int argc, char **argv){
    if(argc == 1){
        while(1){
            puts("y");
        }
    }
    else {
        while(1){
            for(int i = 1; i < argc; i++){
                printf("%s", argv[i]);
                if(argc - i > 1){
                    putchar(' ');
                }
            }
            putchar('\n');
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x1180
leaq 0xe8e(%rip), %rbx       # 0x2004
movq %rbx, %rdi
callq 0x1040
jmp 0x1176
movq %rsi, %rbx
movslq %edi, %r13
leaq -0x1(%r13), %r15
pushq $0x1
popq %r14
movq %r14, %r12
cmpq %r13, %r14
jge 0x11ba
movq (%rbx,%r14,8), %rsi
leaq 0xe65(%rip), %rdi       # 0x2006
xorl %eax, %eax
callq 0x1050
cmpq %r15, %r14
jge 0x11b5
pushq $0x20
popq %rdi
callq 0x1030
incq %r14
jmp 0x1191
pushq $0xa
popq %rdi
callq 0x1030
movq %r12, %r14
jmp 0x1191
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/dtos8cvt/dtos8cvt.c
// Function: main
int main (int argc, char *argv[])
{
int i, k;
unsigned short buf[BLKSIZ];
char *ppos, oname[256];
FILE *ifile, *ofile;

if ((argc < 2) || (argv[0] == NULL)) {
	printf ("Usage is: verb file [file...]\n");
	exit (0);  }

for (i = 1; i < argc; i++) {
	strcpy (oname, argv[i]);
        if (ppos = strrchr (oname, '.')) strcpy (ppos, ".dt8");
                else strcat (oname, ".dt8");
	ifile = fopen (argv[i], "rb");
	if (ifile == NULL) {
		printf ("Error opening file: %s\n", argv[i]);
		exit (0);  }
	ofile = fopen (oname, "wb");
	if (ofile == NULL) {
		printf ("Error opening file: %s\n", oname);
		exit (0);  }

	printf ("Processing file %s\n", argv[i]);
	for (;;) {
		k = fread (buf, sizeof (short), BLKSIZ - 1, ifile);
		if (k == 0) break;
		for ( ; k < BLKSIZ; k++) buf[k] = 0;
		fwrite (buf, sizeof (short), BLKSIZ, ofile);
		}
	fclose (ifile);
	fclose (ofile);
	}

return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
cmpl $0x2, %edi
jl 0x1355
movq %rsi, %rbx
cmpq $0x0, (%rsi)
je 0x1355
movl %edi, %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rax
leaq 0x10(%rsp), %r13
leaq 0x110(%rsp), %rbp
pushq $0x2
popq %r15
cmpq 0x8(%rsp), %rax
je 0x1316
movq (%rbx,%rax,8), %r12
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %r14
callq 0x1030
movq %r13, %rdi
pushq $0x2e
popq %rsi
callq 0x1090
testq %rax, %rax
movq %r14, (%rsp)
je 0x124f
movb $0x0, 0x4(%rax)
movl $0x3874642e, (%rax)     # imm = 0x3874642E
movq (%rbx,%r14,8), %r12
jmp 0x1264
movq %r13, %rdi
callq 0x1070
movl $0x3874642e, 0x10(%rsp,%rax) # imm = 0x3874642E
movb $0x0, 0x14(%rsp,%rax)
movq %r12, %rdi
leaq 0xd9b(%rip), %rsi       # 0x2009
callq 0x10a0
testq %rax, %rax
je 0x132a
movq %rax, %r12
movq %r13, %r14
movq %r13, %rdi
leaq 0xd98(%rip), %rsi       # 0x2024
callq 0x10a0
testq %rax, %rax
je 0x133b
movq %rax, %r13
movq (%rsp), %rax
movq (%rbx,%rax,8), %rsi
leaq 0xd7b(%rip), %rdi       # 0x2027
xorl %eax, %eax
callq 0x1080
movl $0x80, %edx
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x1050
testl %eax, %eax
je 0x12f7
cltq
cmpq $0x80, %rax
jg 0x12e2
andw $0x0, 0x110(%rsp,%rax,2)
incq %rax
jmp 0x12cc
movl $0x81, %edx
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x10c0
jmp 0x12b3
movq %r12, %rdi
callq 0x1060
movq %r13, %rdi
callq 0x1060
movq (%rsp), %rax
incq %rax
movq %r14, %r13
jmp 0x120e
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movq (%rbx,%rax,8), %rsi
leaq 0xcd3(%rip), %rdi       # 0x200c
jmp 0x1347
leaq 0xcca(%rip), %rdi       # 0x200c
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1080
xorl %edi, %edi
callq 0x10b0
leaq 0xcdf(%rip), %rdi       # 0x203b
callq 0x1040
jmp 0x134e
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_22/fold_line.c
// Function: main
int main(void)
{
  char line[MAXLINE];
  char fold_str[MAXLINE];

  while ((get_line(line, MAXLINE)) > 0)
  {
    fold_line(line, fold_str, BREAKING_POINT);
    printf("%s", fold_str);
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4e28, %rsp           # imm = 0x4E28
leaq 0x2710(%rsp), %rbx
movq %rsp, %r14
pushq $0x28
popq %rbp
leaq 0xe96(%rip), %r15       # 0x2004
movq %rbx, %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11ab
testl %eax, %eax
jle 0x119b
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1200
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x116e
xorl %eax, %eax
addq $0x4e28, %rsp           # imm = 0x4E28
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_22/fold_line.c
// Function: get_line
int get_line(char line[], int max_line_len)
{
  int c, i = 0;

  while (i < max_line_len - 1 && (c = getchar()) != EOF && c != '\n')
  {
    line[i++] = c;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
pushq $0x1
popq %r14
cmovgel %esi, %r14d
decl %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x11e4
callq 0x1040
cmpl $-0x1, %eax
je 0x11e1
cmpl $0xa, %eax
je 0x11e1
movb %al, (%rbx,%r15)
incq %r15
jmp 0x11c4
movl %r15d, %r14d
cmpl $0xa, %eax
jne 0x11f3
movl %r14d, %eax
incl %r14d
movb $0xa, (%rbx,%rax)
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_22/fold_line.c
// Function: fold_line
void fold_line(char line[], char fold_str[], int n_break)
{
  int i, j;
  int column = 0;
  int split = FALSE;
  int last_blank = 0;

  for (i = 0, j = 0; line[i] != '\0'; ++i, ++j)
  {
    fold_str[j] = line[i];

    if (fold_str[j] == '\n')
    {
      column = 0;
    }

    column++;

    if (column == n_break - OFFSET)
    {
      split = TRUE;
    }

    if (split && (fold_str[j] == ' ' || fold_str[j] == '\t'))
    {
      last_blank = j;
    }

    if (column == n_break)
    {
      if (last_blank)
      {
        fold_str[last_blank] = '\n';
        column = j - last_blank;
        last_blank = 0;
      }
      else
      {
        fold_str[j++] = '-';
        fold_str[j] = '\n';

        column = 0;
      }

      split = FALSE;
    }
  }

  fold_str[j] = '\0';
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leal -0xb(%rdx), %eax
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %ebx, %ebx
xorl %r11d, %r11d
movzbl (%rdi), %ebp
movslq %r9d, %r14
testl %ebp, %ebp
je 0x1284
movb %bpl, (%rsi,%r14)
cmpb $0xa, %bpl
cmovel %ecx, %r10d
cmpl %eax, %r10d
cmovel %r8d, %ebx
testl %ebx, %ebx
je 0x1248
cmpl $0x20, %ebp
je 0x1245
cmpl $0x9, %ebp
jne 0x1248
movl %r9d, %r11d
incl %r10d
cmpl %edx, %r10d
jne 0x127c
testl %r11d, %r11d
jne 0x1269
leaq 0x1(%r14), %r9
movb $0x2d, (%rsi,%r14)
movb $0xa, 0x1(%rsi,%r14)
xorl %r10d, %r10d
jmp 0x1277
movslq %r11d, %r10
movb $0xa, (%rsi,%r10)
movl %r9d, %r10d
subl %r11d, %r10d
xorl %ebx, %ebx
xorl %r11d, %r11d
incl %r9d
incq %rdi
jmp 0x121a
movb $0x0, (%rsi,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PARKINHYO[P]BlackjackGame/fifo/fifo_server.c
// Function: set_shutdown
void *set_shutdown ()
{
        printf("[SIGNAL] : Got shutdown signal\n");
        semctl( gnSemID1, IPC_RMID, 0 );
        printf("[SIGNAL] : Semapore segment marked for deletion\n");
        exit (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x54c(%rip), %rdi       # 0x2307
callq 0x1050
movl 0x23ce(%rip), %edi      # 0x4194
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1140
leaq 0x54e(%rip), %rdi       # 0x2326
callq 0x1050
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_05/strncat.c
// Function: main
int main(void)
{
  char s[100] = "This is the first string";
  char *t = ", this second string!";
  size_t nr_chars = 5;

  strcat_ptr(s, t, nr_chars);

  puts(s);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0xeb8(%rip), %rsi       # 0x2010
pushq $0x64
popq %rcx
movq %rsp, %rbx
movq %rbx, %rdi
rep  movsb (%rsi), %es:(%rdi)
leaq 0xf0a(%rip), %rsi       # 0x2074
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x1185
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/crossover/crossover.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        printf("usage: fader -n<N> [<input rra file> [<output rra file>]]\n");
        exit(-1);
        }

    h = newRRAHeader();
    
    readRRAHeader(in,h,0);

    process(h);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
pushq $0x1
popq %r15
movslq %r15d, %r13
cmpl %r15d, %r14d
jle 0x1409
movq (%rbx,%r13,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x1409
movb 0x2(%rsi), %r12b
testb %r12b, %r12b
je 0x138c
leaq 0x2(%rsi), %rdi
jmp 0x1391
movq 0x8(%rbx,%r13,8), %rdi
movzbl 0x1(%rsi), %eax
cmpl $0x69, %eax
je 0x13cd
cmpl $0x6f, %eax
je 0x13e5
cmpl $0x76, %eax
je 0x14c6
xorl %r13d, %r13d
leaq 0x1cc1(%rip), %rdi      # 0x3073
xorl %eax, %eax
callq 0x1604
testb %r12b, %r12b
sete %al
andb %r13b, %al
movzbl %al, %eax
addl %eax, %r15d
incl %r15d
jmp 0x1364
callq 0x11f0
movq 0x4c1f(%rip), %rcx      # 0x5ff8
movq (%rcx), %rdi
leaq 0x1c66(%rip), %rsi      # 0x3049
jmp 0x13fb
callq 0x11f0
movq 0x4c07(%rip), %rcx      # 0x5ff8
movq (%rcx), %rdi
leaq 0x1c5b(%rip), %rsi      # 0x3056
movl %eax, %edx
xorl %eax, %eax
callq 0x1140
movb $0x1, %r13b
jmp 0x13b9
subl %r15d, %r14d
jne 0x141a
movq 0x4bc3(%rip), %rax      # 0x5fd8
movq (%rax), %rax
jmp 0x143a
cmpl $0x2, %r14d
je 0x144d
cmpl $0x1, %r14d
jne 0x14e9
movq (%rbx,%r13,8), %rdi
leaq 0x1bea(%rip), %rsi      # 0x301f
callq 0x1734
movq %rax, 0x4d1f(%rip)      # 0x6160
movq 0x4b88(%rip), %rax      # 0x5fd0
movq (%rax), %rax
jmp 0x1475
movq (%rbx,%r13,8), %rdi
leaq 0x1bc7(%rip), %rsi      # 0x301f
callq 0x1734
movq %rax, 0x4cfc(%rip)      # 0x6160
movq 0x8(%rbx,%r13,8), %rdi
leaq 0x1b99(%rip), %rsi      # 0x3009
callq 0x1734
movq %rax, 0x4cec(%rip)      # 0x6168
callq 0x1990
movq %rax, %rbx
movq 0x4cd5(%rip), %rdi      # 0x6160
movq %rax, %rsi
xorl %edx, %edx
callq 0x1cf5
movq %rbx, %rdi
callq 0x14fd
movq 0x4cbc(%rip), %rdi      # 0x6160
callq 0x1090
movq 0x4cb8(%rip), %rdi      # 0x6168
callq 0x1090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4c6b(%rip), %rsi      # 0x6138
movq 0x4c6c(%rip), %rdx      # 0x6140
leaq 0x1b89(%rip), %rdi      # 0x3064
xorl %eax, %eax
callq 0x10b0
xorl %edi, %edi
callq 0x1200
leaq 0x1b9d(%rip), %rdi      # 0x308d
callq 0x1070
pushq $-0x1
popq %rdi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.9/tifftest.c
// Function: main
int main (int argc, char** argv)
{
	if(!(argc-1)){
		printf("Error al abrir el archivo.");
		return 0;
	}
	TIFF* tiff;
	char dir[70] = "../../src/capitulo_2/2.9/";
  //char dir[70] = "./";

	strcat(dir, argv[1]);
	tiff = TIFFOpen (dir, "r");
	if (tiff) {
		int dircount = 0;
		do {
		    dircount++;
	} while (TIFFReadDirectory(tiff));
		  printf("%d directorios en %s\n", dircount, argv[1]);
      TIFFClose(tiff);
  }

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
jne 0x119e
leaq 0xe6f(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
jmp 0x1206
movq %rsi, %rbx
leaq 0xe98(%rip), %rsi       # 0x2040
pushq $0x46
popq %rcx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
rep  movsb (%rsi), %es:(%rdi)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1050
leaq 0xe58(%rip), %rsi       # 0x201f
movq %r14, %rdi
callq 0x1070
testq %rax, %rax
je 0x1206
movq %rax, %r14
xorl %r15d, %r15d
incl %r15d
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
jne 0x11da
movq 0x8(%rbx), %rdx
leaq 0xe2d(%rip), %rdi       # 0x2021
movl %r15d, %esi
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalSource
int Jim_EvalSource(Jim_Interp *interp, const char *filename, int lineno, const char *script)
{
    int retval;
    Jim_Obj *scriptObjPtr;

    scriptObjPtr = Jim_NewStringObj(interp, script, -1);
    Jim_IncrRefCount(scriptObjPtr);
    if (filename) {
        Jim_SetSourceInfo(interp, scriptObjPtr, Jim_NewStringObj(interp, filename, -1), lineno);
    }
    retval = Jim_EvalObj(interp, scriptObjPtr);
    Jim_DecrRefCount(interp, scriptObjPtr);
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
pushq $-0x1
popq %rdx
movq %rcx, %rsi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
testq %r12, %r12
je 0x665a
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %r15d, %ecx
callq 0xb3cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b54
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x6683
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_AioFilehandle
int Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command)
{
    Jim_Cmd *cmdPtr = Jim_GetCommand(interp, command, JIM_ERRMSG);


    if (cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc) {
        return ((AioFile *) cmdPtr->u.native.privData)->fd;
    }
    Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", command);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdx
callq 0x6755
testq %rax, %rax
je 0x6730
cmpl $0x0, 0x4(%rax)
jne 0x6730
leaq 0x13d(%rip), %rcx       # 0x6867
cmpq %rcx, 0x18(%rax)
je 0x674c
leaq 0x202dc(%rip), %rsi     # 0x26a13
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
jmp 0x6747
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetCommand
Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
{
    Jim_Cmd *cmd;

    if (objPtr->typePtr == &commandObjType
        && objPtr->internalRep.cmdValue.procEpoch == interp->procEpoch
#ifdef jim_ext_namespace
        && Jim_StringEqObj(objPtr->internalRep.cmdValue.nsObj, interp->framePtr->nsObj)
#endif
        && objPtr->internalRep.cmdValue.cmdPtr->inUse) {

        cmd = objPtr->internalRep.cmdValue.cmdPtr;
    }
    else {
        Jim_Obj *qualifiedNameObj = JimQualifyName(interp, objPtr);
        Jim_HashEntry *he = Jim_FindHashEntry(&interp->commands, qualifiedNameObj);
#ifdef jim_ext_namespace
        if (he == NULL && Jim_Length(interp->framePtr->nsObj)) {
            he = Jim_FindHashEntry(&interp->commands, objPtr);
        }
#endif
        if (he == NULL) {
            if (flags & JIM_ERRMSG) {
                Jim_SetResultFormatted(interp, "invalid command name \"%#s\"", objPtr);
            }
            Jim_DecrRefCount(interp, qualifiedNameObj);
            return NULL;
        }
        cmd = Jim_GetHashEntryVal(he);

        cmd->cmdNameObj = Jim_GetHashEntryKey(he);


        Jim_FreeIntRep(interp, objPtr);
        objPtr->typePtr = &commandObjType;
        objPtr->internalRep.cmdValue.procEpoch = interp->procEpoch;
        objPtr->internalRep.cmdValue.cmdPtr = cmd;
        objPtr->internalRep.cmdValue.nsObj = interp->framePtr->nsObj;
        Jim_IncrRefCount(interp->framePtr->nsObj);
        Jim_DecrRefCount(interp, qualifiedNameObj);
    }
    while (cmd->u.proc.upcall) {
        cmd = cmd->prevCmd;
    }
    return cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2ab65(%rip), %r13     # 0x312d8
cmpq %r13, 0x8(%rsi)
jne 0x6794
movq 0x28(%rbx), %rax
cmpq 0x98(%r14), %rax
jne 0x6794
movq 0x20(%rbx), %r15
cmpl $0x0, (%r15)
jne 0x6816
incl 0x10(%rbx)
leaq 0x68(%r14), %rdi
movq %rbx, %rsi
callq 0xa3fb
testq %rax, %rax
je 0x681f
movq (%rax), %rcx
movq 0x8(%rax), %r15
movq %rcx, 0x10(%r15)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x67cd
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x67cd
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %r13, 0x8(%rbx)
movq 0x98(%r14), %rax
movq %rax, 0x28(%rbx)
movq %r15, 0x20(%rbx)
movq 0x58(%r14), %rax
movq 0x78(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x58(%r14), %rax
movq 0x78(%rax), %rax
incl 0x10(%rax)
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0x6816
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73bf
jmp 0x6816
movq 0x8(%r15), %r15
cmpl $0x0, 0x40(%r15)
jne 0x6812
jmp 0x6855
testb $0x1, %r12b
je 0x6839
leaq 0x2047d(%rip), %rsi     # 0x26ca9
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x68a7
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0x6852
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73bf
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_aioInit
int Jim_aioInit(Jim_Interp *interp)
{
    if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG))
        return JIM_ERR;

#if defined(JIM_SSL)
    Jim_CreateCommand(interp, "load_ssl_certs", JimAioLoadSSLCertsCommand, NULL, NULL);
#endif

    Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL);
#ifdef HAVE_SOCKETS
    Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
#endif
#ifdef HAVE_PIPE
    Jim_CreateCommand(interp, "pipe", JimAioPipeCommand, NULL, NULL);
#endif


    JimMakeChannel(interp, fileno(stdin), NULL, "stdin", 0, AIO_KEEPOPEN);
    JimMakeChannel(interp, fileno(stdout), NULL, "stdout", 0, AIO_KEEPOPEN);
    JimMakeChannel(interp, fileno(stderr), NULL, "stderr", 0, AIO_KEEPOPEN | AIO_WBUF_NONE);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x20a9b(%rip), %rsi     # 0x275a0
leaq 0xde(%rip), %rdx        # 0x6bea
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6bac
leaq 0x20e84(%rip), %rsi     # 0x279a1
leaq 0x354(%rip), %rdx       # 0x6e78
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6bac
movq 0x2c450(%rip), %rax     # 0x32f88
movq (%rax), %rdi
callq 0x6340
leaq 0x1fee4(%rip), %rcx     # 0x26a2b
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl %r14d, %r8d
callq 0x6f74
movq 0x2c417(%rip), %rax     # 0x32f78
movq (%rax), %rdi
callq 0x6340
leaq 0x1fec1(%rip), %rcx     # 0x26a31
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl %r14d, %r8d
callq 0x6f74
movq 0x2c472(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
callq 0x6340
leaq 0x1fea3(%rip), %rcx     # 0x26a38
pushq $0x9
popq %r8
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x6f74
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimAioPipeCommand
static int JimAioPipeCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 1) {
        Jim_WrongNumArgs(interp, 1, argv, "");
        return JIM_ERR;
    }
    return JimCreatePipe(interp, argv[0], 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x6f30
movq (%rdx), %r14
leaq -0x20(%rbp), %rdi
callq 0x6270
testl %eax, %eax
jne 0x6f58
movl -0x20(%rbp), %esi
leaq 0x20767(%rip), %rcx     # 0x27613
movq %rbx, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x6f74
testq %rax, %rax
je 0x6f48
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r15
movq (%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x74ad
movl -0x1c(%rbp), %esi
leaq 0x20729(%rip), %rcx     # 0x27613
movq %rbx, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x6f74
testq %rax, %rax
je 0x6f48
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74ad
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x6f28
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
xorl %r14d, %r14d
jmp 0x6f66
leaq 0x2270a(%rip), %rcx     # 0x29641
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
jmp 0x6f66
movl -0x20(%rbp), %edi
callq 0x6260
movl -0x1c(%rbp), %edi
callq 0x6260
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12fac
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ReaddirCmd
int Jim_ReaddirCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *dirPath;
    DIR *dirPtr;
    struct dirent *entryPtr;
    int nocomplain = 0;

    if (argc == 3 && Jim_CompareStringImmediate(interp, argv[1], "-nocomplain")) {
        nocomplain = 1;
    }
    if (argc != 2 && !nocomplain) {
        Jim_WrongNumArgs(interp, 1, argv, "?-nocomplain? dirPath");
        return JIM_ERR;
    }

    dirPath = Jim_String(argv[1 + nocomplain]);

    dirPtr = opendir(dirPath);
    if (dirPtr == NULL) {
        if (nocomplain) {
            return JIM_OK;
        }
        Jim_SetResultString(interp, strerror(errno), -1);
        return JIM_ERR;
    }
    else {
        Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);

        while ((entryPtr = readdir(dirPtr)) != NULL) {
            if (entryPtr->d_name[0] == '.') {
                if (entryPtr->d_name[1] == '\0') {
                    continue;
                }
                if ((entryPtr->d_name[1] == '.') && (entryPtr->d_name[2] == '\0'))
                    continue;
            }
            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, entryPtr->d_name, -1));
        }
        closedir(dirPtr);

        Jim_SetResult(interp, listObj);

        return JIM_OK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x3, %esi
jne 0x70fd
movq 0x8(%r14), %rsi
leaq 0x1f95b(%rip), %rdx     # 0x26a3f
movq %rbx, %rdi
callq 0x7223
xorl %r12d, %r12d
testl %eax, %eax
setne %r12b
movq %r12, %rax
incq %rax
jmp 0x7103
pushq $0x1
popq %rax
xorl %r12d, %r12d
cmpl $0x2, %r15d
sete %cl
orb %r12b, %cl
je 0x7187
movq (%r14,%rax,8), %rdi
callq 0x7340
movq %rax, %rdi
callq 0x6160
testq %rax, %rax
je 0x71cf
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
pushq $-0x1
popq %r12
movq %r15, %rdi
callq 0x6410
testq %rax, %rax
je 0x71a2
cmpb $0x2e, 0x13(%rax)
jne 0x7165
movzbl 0x14(%rax), %ecx
testl %ecx, %ecx
je 0x713f
cmpl $0x2e, %ecx
jne 0x7165
cmpb $0x0, 0x15(%rax)
je 0x713f
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
jmp 0x713f
leaq 0x1f8bd(%rip), %rcx     # 0x26a4b
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x7217
movq %r15, %rdi
callq 0x6280
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x71c7
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x7217
xorl %r15d, %r15d
testb %r12b, %r12b
jne 0x7217
callq 0x6080
movl (%rax), %edi
callq 0x64b0
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x7210
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
pushq $0x1
popq %r15
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CompareStringImmediate
int Jim_CompareStringImmediate(Jim_Interp *interp, Jim_Obj *objPtr, const char *str)
{
    if (objPtr->typePtr == &comparedStringObjType && objPtr->internalRep.ptr == str) {
        return 1;
    }
    else {
        if (strcmp(str, Jim_String(objPtr)) != 0)
            return 0;

        if (objPtr->typePtr != &comparedStringObjType) {
            Jim_FreeIntRep(interp, objPtr);
            objPtr->typePtr = &comparedStringObjType;
        }
        objPtr->internalRep.ptr = (char *)str;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2a01f(%rip), %r13     # 0x31260
pushq $0x1
popq %r12
cmpq %r13, 0x8(%rsi)
jne 0x7251
cmpq %rbx, 0x18(%r14)
je 0x7293
movq %r14, %rdi
callq 0x7340
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x7296
movq 0x8(%r14), %rax
cmpq %r13, %rax
je 0x728f
testq %rax, %rax
je 0x728b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x728b
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r13, 0x8(%r14)
movq %rbx, 0x18(%r14)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_WrongNumArgs
void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const char *msg)
{
    Jim_Obj *objPtr;
    Jim_Obj *listObjPtr;

    JimPanic((argc == 0, "Jim_WrongNumArgs() called with argc=0"));

    listObjPtr = Jim_NewListObj(interp, argv, argc);

    if (msg && *msg) {
        Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, msg, -1));
    }
    Jim_IncrRefCount(listObjPtr);
    objPtr = Jim_ListJoin(interp, listObjPtr, " ", 1);
    Jim_DecrRefCount(interp, listObjPtr);

    Jim_SetResultFormatted(interp, "wrong # args: should be \"%#s\"", objPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %esi, %eax
movq %rdi, %rbx
movq %rdx, %rsi
movl %eax, %edx
callq 0x745b
movq %rax, %r14
testq %r15, %r15
je 0x72eb
cmpb $0x0, (%r15)
je 0x72eb
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
incl 0x10(%r14)
leaq 0x2226e(%rip), %rdx     # 0x29564
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdc89
movq %rax, %r15
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x7322
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
leaq 0x1fc9e(%rip), %rsi     # 0x26fc7
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x68a7
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewStringObj
Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len)
{
    Jim_Obj *objPtr = Jim_NewObj(interp);


    if (len == -1)
        len = strlen(s);

    if (len == 0) {
        objPtr->bytes = JimEmptyStringRep;
    }
    else {
        objPtr->bytes = Jim_StrDupLen(s, len);
    }
    objPtr->length = len;


    objPtr->typePtr = NULL;
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
callq 0xa5c2
movq %rax, %rbx
cmpl $-0x1, %r14d
jne 0x738c
movq %r15, %rdi
callq 0x6180
movq %rax, %r14
testl %r14d, %r14d
je 0x739e
movq %r15, %rdi
movl %r14d, %esi
callq 0x9e36
jmp 0x73a5
leaq 0x2bef3(%rip), %rax     # 0x33298
movq %rax, (%rbx)
movl %r14d, 0x14(%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_FreeObj
void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr)
{

    JimPanic((objPtr->refCount != 0, "!!!Object %p freed with bad refcount %d, type=%s", objPtr,
        objPtr->refCount, objPtr->typePtr ? objPtr->typePtr->name : "<none>"));


    Jim_FreeIntRep(interp, objPtr);

    if (objPtr->bytes != NULL) {
        if (objPtr->bytes != JimEmptyStringRep)
            Jim_Free(objPtr->bytes);
    }

    if (objPtr->prevObjPtr)
        objPtr->prevObjPtr->nextObjPtr = objPtr->nextObjPtr;
    if (objPtr->nextObjPtr)
        objPtr->nextObjPtr->prevObjPtr = objPtr->prevObjPtr;
    if (interp->liveList == objPtr)
        interp->liveList = objPtr->nextObjPtr;
#ifdef JIM_DISABLE_OBJECT_POOL
    Jim_Free(objPtr);
#else

    objPtr->prevObjPtr = NULL;
    objPtr->nextObjPtr = interp->freeList;
    if (interp->freeList)
        interp->freeList->prevObjPtr = objPtr;
    interp->freeList = objPtr;
    objPtr->refCount = -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x73e6
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x73e6
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x2bea2(%rip), %rcx     # 0x33298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x7408
xorl %esi, %esi
callq *0x2be80(%rip)          # 0x33288
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
testq %rcx, %rcx
je 0x7419
movq %rax, 0x38(%rcx)
testq %rax, %rax
je 0x7422
movq %rcx, 0x30(%rax)
cmpq %rbx, 0xb8(%r14)
jne 0x7432
movq %rax, 0xb8(%r14)
andq $0x0, 0x30(%rbx)
movq 0xc0(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x744b
movq %rbx, 0x30(%rax)
movq %rbx, 0xc0(%r14)
orl $-0x1, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewListObj
Jim_Obj *Jim_NewListObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
{
    Jim_Obj *objPtr;

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &listObjType;
    objPtr->bytes = NULL;
    objPtr->internalRep.listValue.ele = NULL;
    objPtr->internalRep.listValue.len = 0;
    objPtr->internalRep.listValue.maxLen = 0;

    if (len) {
        ListInsertElements(objPtr, 0, len, elements);
    }

    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
callq 0xa5c2
movq %rax, %r15
leaq 0x29f8e(%rip), %rax     # 0x31408
movq %rax, 0x8(%r15)
andq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
testl %r14d, %r14d
je 0x749f
movq %r15, %rdi
xorl %esi, %esi
movl %r14d, %edx
movq %rbx, %rcx
callq 0xd439
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetIndex
int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr)
{

    if (objPtr->typePtr == &intObjType) {
        jim_wide val = JimWideValue(objPtr);

        if (val < 0)
            *indexPtr = -INT_MAX;
        else if (val > INT_MAX)
            *indexPtr = INT_MAX;
        else
            *indexPtr = (int)val;
        return JIM_OK;
    }
    if (objPtr->typePtr != &indexObjType && SetIndexFromAny(interp, objPtr) == JIM_ERR)
        return JIM_ERR;
    *indexPtr = objPtr->internalRep.intValue;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x29628(%rip), %rcx     # 0x31390
cmpq %rcx, %rax
je 0x7ddd
leaq 0x296e4(%rip), %r13     # 0x31458
cmpq %r13, %rax
je 0x7e5a
movq %rdi, %r15
movq %r14, %rdi
callq 0x7340
cmpb $0x65, (%rax)
jne 0x7dfe
cmpb $0x6e, 0x1(%rax)
jne 0x7dfe
cmpb $0x64, 0x2(%rax)
jne 0x7dfe
andq $0x0, -0x38(%rbp)
movzbl 0x3(%rax), %ecx
testl %ecx, %ecx
je 0x7eaa
cmpl $0x2d, %ecx
je 0x7db8
cmpl $0x2b, %ecx
jne 0x7e41
addq $0x3, %rax
pushq $-0x1
popq %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x7363
testq %rax, %rax
je 0x7ea1
movq %rax, %r12
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x7e08
movq 0x18(%r14), %rax
testq %rax, %rax
js 0x7e60
movq %rax, %rcx
shrq $0x1f, %rcx
je 0x7e86
movl $0x7fffffff, (%rbx)     # imm = 0x7FFFFFFF
jmp 0x7ed5
movl $0x0, -0x2c(%rbp)
movq %r14, %r12
incl 0x10(%r12)
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xcace
movl %eax, %r13d
movl 0x10(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r12)
cmpl $0x1, %eax
jg 0x7e3c
movq %r15, %rdi
movq %r12, %rsi
callq 0x73bf
testl %r13d, %r13d
je 0x7e68
leaq 0x1ff84(%rip), %rsi     # 0x27dcc
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
jmp 0x7ed7
movl 0x18(%r14), %r12d
jmp 0x7ed2
movl $0x80000001, (%rbx)     # imm = 0x80000001
jmp 0x7ed5
movq -0x38(%rbp), %rcx
cmpb $0x0, -0x2c(%rbp)
je 0x7e8a
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
testq %rcx, %rcx
leaq 0x295d6(%rip), %r13     # 0x31458
jg 0x7eb0
jmp 0x7eaa
movl %eax, (%rbx)
jmp 0x7ed5
testq %rcx, %rcx
movq $-0x7fffffff, %r12      # imm = 0x80000001
cmovnsq %rcx, %r12
leaq 0x295b9(%rip), %r13     # 0x31458
jmp 0x7eb0
xorl %ecx, %ecx
leaq 0x295ae(%rip), %r13     # 0x31458
decq %rcx
movq %rcx, %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7eca
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7eca
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r13, 0x8(%r14)
movl %r12d, 0x18(%r14)
movl %r12d, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: SetRegexpFromAny
static regex_t *SetRegexpFromAny(Jim_Interp *interp, Jim_Obj *objPtr, unsigned flags)
{
    regex_t *compre;
    const char *pattern;
    int ret;


    if (objPtr->typePtr == &regexpObjType &&
        objPtr->internalRep.ptrIntValue.ptr && objPtr->internalRep.ptrIntValue.int1 == flags) {

        return objPtr->internalRep.ptrIntValue.ptr;
    }




    pattern = Jim_String(objPtr);
    compre = Jim_Alloc(sizeof(regex_t));

    if ((ret = jim_regcomp(compre, pattern, REG_EXTENDED | flags)) != 0) {
        char buf[100];

        jim_regerror(ret, compre, buf, sizeof(buf));
        Jim_SetResultFormatted(interp, "couldn't compile regular expression pattern: %s", buf);
        jim_regfree(compre);
        Jim_Free(compre);
        return NULL;
    }

    Jim_FreeIntRep(interp, objPtr);

    objPtr->typePtr = &regexpObjType;
    objPtr->internalRep.ptrIntValue.int1 = flags;
    objPtr->internalRep.ptrIntValue.ptr = compre;

    return compre;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
leaq 0x29db1(%rip), %rax     # 0x31cb8
cmpq %rax, 0x8(%rsi)
je 0x7f77
movq %r15, %rdi
callq 0x7340
movq %rax, %r13
pushq $0x68
popq %rsi
xorl %edi, %edi
callq *0x2b365(%rip)          # 0x33288
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x114a0
testl %eax, %eax
je 0x7f88
leaq -0x90(%rbp), %r15
pushq $0x64
popq %rcx
movl %eax, %edi
movq %r15, %rdx
callq 0x81d2
leaq 0x1f6cc(%rip), %rsi     # 0x2761f
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x68a7
movq %rbx, %rdi
callq 0x11921
movq %rbx, %rdi
xorl %esi, %esi
callq *0x2b315(%rip)          # 0x33288
xorl %ebx, %ebx
jmp 0x7fb5
movq 0x18(%r15), %rbx
testq %rbx, %rbx
je 0x7f0d
cmpl %r12d, 0x20(%r15)
jne 0x7f0d
jmp 0x7fb5
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x7fa2
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7fa2
movq %r14, %rdi
movq %r15, %rsi
callq *%rax
leaq 0x29d0f(%rip), %rax     # 0x31cb8
movq %rax, 0x8(%r15)
movl %r12d, 0x20(%r15)
movq %rbx, 0x18(%r15)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetString
const char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr)
{
    if (objPtr->bytes == NULL) {

        JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name));
        objPtr->typePtr->updateStringProc(objPtr);
    }
    if (lenPtr)
        *lenPtr = objPtr->length;
    return objPtr->bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x7fe4
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x7fef
movl 0x14(%rbx), %eax
movl %eax, (%r14)
movq (%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewIntObj
Jim_Obj *Jim_NewIntObj(Jim_Interp *interp, jim_wide wideValue)
{
    Jim_Obj *objPtr;

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &intObjType;
    objPtr->bytes = NULL;
    objPtr->internalRep.wideValue = wideValue;
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xa5c2
leaq 0x29169(%rip), %rcx     # 0x31390
movq %rcx, 0x8(%rax)
andq $0x0, (%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetVariable
int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
{
    int err;
    Jim_VarVal *vv;

    switch (SetVariableFromAny(interp, nameObjPtr)) {
        case JIM_DICT_SUGAR:
            return JimDictSugarSet(interp, nameObjPtr, valObjPtr);

        case JIM_ERR:
            JimCreateVariable(interp, nameObjPtr, valObjPtr);
            break;

        case JIM_OK:
            vv = nameObjPtr->internalRep.varValue.vv;
            if (vv->linkFramePtr == NULL) {
                Jim_IncrRefCount(valObjPtr);
                Jim_DecrRefCount(interp, vv->objPtr);
                vv->objPtr = valObjPtr;
            }
            else {
                Jim_CallFrame *savedCallFrame;

                savedCallFrame = interp->framePtr;
                interp->framePtr = vv->linkFramePtr;
                err = Jim_SetVariable(interp, vv->objPtr, valObjPtr);
                interp->framePtr = savedCallFrame;
                if (err != JIM_OK)
                    return err;
            }
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb6e9
testl %eax, %eax
je 0x83a0
cmpl $0x1, %eax
je 0x8350
cmpl $0x64, %eax
jne 0x846b
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb86c
xorl %r13d, %r13d
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *0x2af2a(%rip)          # 0x33288
movq %rax, %r15
movq %r12, (%rax)
incl 0x10(%r12)
andq $0x0, 0x8(%rax)
andl $0x0, 0x10(%rax)
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq 0x7fc7
cmpb $0x3a, (%rax)
jne 0x83d7
cmpb $0x3a, 0x1(%rax)
jne 0x83d7
movb $0x3a, %cl
movl -0x2c(%rbp), %edx
cmpb $0x3a, %cl
jne 0x8410
decl %edx
movl %edx, -0x2c(%rbp)
movb 0x1(%rax), %cl
incq %rax
jmp 0x838e
movq 0x18(%r14), %r14
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x83ed
movq 0x58(%rbx), %r15
movq %rax, 0x58(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8306
movq %r15, 0x58(%rbx)
testl %eax, %eax
je 0x846b
pushq $0x1
popq %rax
jmp 0x846d
movq 0x58(%rbx), %r12
leaq 0x10(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa043
jmp 0x8436
incl 0x10(%r12)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x840b
movq %rbx, %rdi
callq 0x73bf
movq %r12, (%r14)
jmp 0x846b
movq 0x60(%rbx), %r12
leaq 0x10(%r12), %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
movq %r13, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xa043
pushq $0x1
popq %r13
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x8450
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x8450
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
leaq 0x29901(%rip), %rax     # 0x31d58
movq %rax, 0x8(%r14)
movq (%r12), %rax
movq %rax, 0x20(%r14)
movq %r15, 0x18(%r14)
movl %r13d, 0x28(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq