LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xa86e(%rip), %rax      # 0xe2b9
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0xf8b8(%rip), %rax      # 0x13310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl $0xaa, 0xc(%rbx)
leaq 0xc439(%rip), %rcx      # 0xfeac
movq %rcx, 0x10(%rbx)
leaq 0xf6fa(%rip), %rcx      # 0x13178
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0xd87e
leaq 0xa858(%rip), %rdi      # 0xe2ed
callq 0x20b0
leaq 0xa719(%rip), %rdi      # 0xe1ba
callq 0x8f57
movq %rax, %r15
leaq 0xa815(%rip), %rdi      # 0xe2c5
callq 0x8f57
leaq 0xf7c4(%rip), %r12      # 0x13280
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc010
leaq -0x214(%rip), %rsi      # 0x38bd
movq %r14, %rdi
movq %rax, %rdx
callq 0x4716
movq %rax, %r15
leaq 0xa7b5(%rip), %r13      # 0xe29b
movq %r13, %rdi
callq 0x8f57
movq %rax, %rbp
leaq 0xa7d3(%rip), %rdi      # 0xe2cb
callq 0x8f57
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xc010
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x47f3
movq %r13, %rdi
callq 0x8f57
movl $0xab, %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0xc010
movq %rax, %r12
leaq 0xa797(%rip), %rdi      # 0xe2d2
callq 0x8f57
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xc010
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x47f3
movq %r14, %rdi
callq 0x55ec
movl $0xb8, 0xc(%rbx)
movq %rbx, %rdi
callq 0xda03
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0xe91(%rip), %r14       # 0x2010
leaq 0xe91(%rip), %r15       # 0x2017
movq %r14, %rdi
cmpl $0x989680, %ebp         # imm = 0x989680
je 0x11a6
cmpl $0x2faf080, %ebp        # imm = 0x2FAF080
je 0x11a3
cmpl $0x5f5e0ff, %ebp        # imm = 0x5F5E0FF
jne 0x11ab
jmp 0x11af
movq %r15, %rdi
callq 0x1030
incl %ebp
jmp 0x1186
leaq 0xe68(%rip), %rdi       # 0x201e
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
leaq -0x6e(%rip), %rdx       # 0x116c
leaq 0xe23(%rip), %rcx       # 0x2004
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1050
leaq 0xe46(%rip), %r14       # 0x203c
leaq 0xe43(%rip), %r15       # 0x2040
movq %r14, %rdi
cmpl $0x989680, %ebx         # imm = 0x989680
je 0x121d
cmpl $0x2faf080, %ebx        # imm = 0x2FAF080
je 0x121a
cmpl $0x5f5e0ff, %ebx        # imm = 0x5F5E0FF
jne 0x1222
jmp 0x1226
movq %r15, %rdi
callq 0x1030
incl %ebx
jmp 0x11fd
leaq 0xe17(%rip), %rdi       # 0x2044
callq 0x1030
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1060
leaq 0xde0(%rip), %rdi       # 0x2025
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x135f
movq %rsi, %rbx
cmpq $0x0, (%rsi)
je 0x135f
movl %edi, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %r13d
leaq 0x10(%rsp), %r14
leaq 0x110(%rsp), %rbp
movq (%rbx,%r13,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1030
movq %r14, %rdi
movl $0x2e, %esi
callq 0x1090
testq %rax, %rax
je 0x124e
movb $0x0, 0x4(%rax)
movl $0x3874642e, (%rax)     # imm = 0x3874642E
movq (%rbx,%r13,8), %r15
jmp 0x1263
movq %r14, %rdi
callq 0x1070
movl $0x3874642e, 0x10(%rsp,%rax) # imm = 0x3874642E
movb $0x0, 0x14(%rsp,%rax)
movq %r15, %rdi
leaq 0xd9c(%rip), %rsi       # 0x2009
callq 0x10b0
testq %rax, %rax
je 0x1338
movq %rax, %r15
movq %r14, %rdi
leaq 0xd9c(%rip), %rsi       # 0x2024
callq 0x10b0
testq %rax, %rax
je 0x1345
movq %rax, %r12
movq (%rbx,%r13,8), %rsi
leaq 0xd83(%rip), %rdi       # 0x2027
xorl %eax, %eax
callq 0x1080
movl $0x2, %esi
movl $0x80, %edx
movq %rbp, %rdi
movq %r15, %rcx
callq 0x1050
testl %eax, %eax
je 0x1306
cmpl $0x80, %eax
jg 0x12ef
movslq %eax, %rcx
leaq (%rsp,%rcx,2), %rdi
addq $0x110, %rdi            # imm = 0x110
movl $0x80, %ecx
subl %eax, %ecx
leaq 0x2(,%rcx,2), %rdx
xorl %esi, %esi
callq 0x10a0
movl $0x2, %esi
movl $0x81, %edx
movq %rbp, %rdi
movq %r12, %rcx
callq 0x10d0
jmp 0x12ab
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x121d
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx,%r13,8), %rsi
leaq 0xcc9(%rip), %rdi       # 0x200c
jmp 0x1351
leaq 0xcc0(%rip), %rdi       # 0x200c
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1080
xorl %edi, %edi
callq 0x10c0
leaq 0xcd5(%rip), %rdi       # 0x203b
callq 0x1040
jmp 0x1358
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x4e20, %rsp           # imm = 0x4E20
movq %rsp, %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11b8
testl %eax, %eax
jle 0x11a9
movq %rsp, %rbx
leaq 0x2710(%rsp), %r14
leaq 0xe89(%rip), %r15       # 0x2004
movq %rbx, %rdi
movq %r14, %rsi
movl $0x28, %edx
callq 0x1216
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11b8
testl %eax, %eax
jg 0x117b
xorl %eax, %eax
addq $0x4e20, %rsp           # imm = 0x4E20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl $0x2, %esi
jl 0x11fa
movl %esi, %ebp
decl %ebp
movl %ebp, %r15d
xorl %r14d, %r14d
callq 0x1040
cmpl $-0x1, %eax
je 0x11f0
cmpl $0xa, %eax
je 0x11f0
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x11d3
jmp 0x11f3
movl %r14d, %ebp
movl %ebp, %ecx
cmpl $0xa, %eax
jne 0x1204
movl %ecx, %eax
incl %ecx
movb $0xa, (%rbx,%rax)
movl %ecx, %ebp
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb (%rdi), %bl
xorl %eax, %eax
testb %bl, %bl
je 0x12af
leal -0xb(%rdx), %ecx
incq %rdi
xorl %r10d, %r10d
xorl %ebp, %ebp
xorl %r9d, %r9d
xorl %r8d, %r8d
movslq %r8d, %r14
movb %bl, (%rsi,%r14)
cmpb $0xa, %bl
cmovel %eax, %r9d
movl $0x1, %r11d
cmpl %ecx, %r9d
je 0x1253
movl %ebp, %r11d
testl %r11d, %r11d
je 0x1268
cmpb $0x20, %bl
je 0x1265
movzbl %bl, %ebx
cmpl $0x9, %ebx
jne 0x1268
movl %r8d, %r10d
incl %r9d
cmpl %edx, %r9d
jne 0x129d
testl %r10d, %r10d
jne 0x1289
leaq 0x1(%r14), %r8
movb $0x2d, (%rsi,%r14)
movb $0xa, 0x1(%rsi,%r14)
xorl %r9d, %r9d
jmp 0x1297
movslq %r10d, %r9
movb $0xa, (%rsi,%r9)
movl %r8d, %r9d
subl %r10d, %r9d
xorl %r11d, %r11d
xorl %r10d, %r10d
incl %r8d
movb (%rdi), %bl
incq %rdi
movl %r11d, %ebp
testb %bl, %bl
jne 0x1237
movslq %r8d, %rax
movb $0x0, (%rsi,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x494(%rip), %rdi       # 0x2307
callq 0x1050
movl 0x2316(%rip), %edi      # 0x4194
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1130
leaq 0x496(%rip), %rdi       # 0x2326
callq 0x1050
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %r12d
cmpl $0x2, %edi
jl 0x1693
movl $0x1, %r12d
movslq %r12d, %rax
movq (%rbx,%rax,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x1693
movb 0x2(%rsi), %r13b
testb %r13b, %r13b
je 0x163c
leaq 0x2(%rsi), %rdi
jmp 0x1641
movq 0x8(%rbx,%rax,8), %rdi
movzbl 0x1(%rsi), %eax
cmpl $0x69, %eax
je 0x1682
cmpl $0x6f, %eax
je 0x1689
cmpl $0x76, %eax
je 0x1756
xorl %r15d, %r15d
leaq 0x2a11(%rip), %rdi      # 0x4073
xorl %eax, %eax
callq 0x18b0
testb %r13b, %r13b
sete %al
andb %r15b, %al
movzbl %al, %eax
addl %eax, %r12d
incl %r12d
cmpl %r14d, %r12d
jl 0x1621
jmp 0x1693
callq 0x1284
jmp 0x168e
callq 0x1260
movb $0x1, %r15b
jmp 0x1669
subl %r12d, %r14d
jne 0x16a4
movq 0x5939(%rip), %rax      # 0x6fd8
movq (%rax), %rax
jmp 0x16c7
cmpl $0x2, %r14d
je 0x16da
cmpl $0x1, %r14d
jne 0x1779
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
leaq 0x295d(%rip), %rsi      # 0x401f
callq 0x194a
movq %rax, 0x5a92(%rip)      # 0x7160
movq 0x58fb(%rip), %rax      # 0x6fd0
movq (%rax), %rax
jmp 0x1705
movslq %r12d, %r14
movq (%rbx,%r14,8), %rdi
leaq 0x2937(%rip), %rsi      # 0x401f
callq 0x194a
movq %rax, 0x5a6c(%rip)      # 0x7160
movq 0x8(%rbx,%r14,8), %rdi
leaq 0x2909(%rip), %rsi      # 0x4009
callq 0x194a
movq %rax, 0x5a5c(%rip)      # 0x7168
callq 0x1bbb
movq %rax, %rbx
movq 0x5a45(%rip), %rdi      # 0x7160
movq %rax, %rsi
xorl %edx, %edx
callq 0x1fe1
movq %rbx, %rdi
callq 0x178f
movq 0x5a2c(%rip), %rdi      # 0x7160
callq 0x1090
movq 0x5a28(%rip), %rdi      # 0x7168
callq 0x1090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x59db(%rip), %rsi      # 0x7138
movq 0x59dc(%rip), %rdx      # 0x7140
leaq 0x28f9(%rip), %rdi      # 0x4064
xorl %eax, %eax
callq 0x10b0
xorl %edi, %edi
callq 0x1200
leaq 0x290d(%rip), %rdi      # 0x408d
callq 0x1070
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1200
// File: /workspace/github_c_makefile_star2_O3/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
movq %rcx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
testq %r12, %r12
je 0x66d2
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x66ba
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x66ba
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
incl 0x10(%r12)
movq %r12, 0x18(%r14)
movl %r15d, 0x20(%r14)
leaq 0x2eb1a(%rip), %rax     # 0x351e8
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x908a
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x66fb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x67aa
cmpl $0x0, 0x4(%rax)
jne 0x67aa
leaq 0x13f(%rip), %rcx       # 0x68e3
cmpq %rcx, 0x18(%rax)
je 0x67c8
leaq 0x24212(%rip), %rsi     # 0x2a9c3
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6923
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
jmp 0x67c3
// File: /workspace/github_c_makefile_star2_O3/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 0x2ea49(%rip), %r13     # 0x35238
cmpq %r13, 0x8(%rsi)
jne 0x6810
movq 0x28(%rbx), %rax
cmpq 0x98(%r14), %rax
jne 0x6810
movq 0x20(%rbx), %r15
cmpl $0x0, (%r15)
jne 0x6892
incl 0x10(%rbx)
leaq 0x68(%r14), %rdi
movq %rbx, %rsi
callq 0xac6b
testq %rax, %rax
je 0x689b
movq (%rax), %rcx
movq 0x8(%rax), %r15
movq %rcx, 0x10(%r15)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x6849
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6849
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 0x6892
movq %r14, %rdi
movq %rbx, %rsi
callq 0x758c
jmp 0x6892
movq 0x8(%r15), %r15
cmpl $0x0, 0x40(%r15)
jne 0x688e
jmp 0x68d1
testb $0x1, %r12b
je 0x68b5
leaq 0x243b1(%rip), %rsi     # 0x2ac59
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6923
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0x68ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0x758c
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_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24996(%rip), %rsi     # 0x2b550
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
leaq 0xfc(%rip), %rdx        # 0x6cc7
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbec5
leaq 0x24d6f(%rip), %rsi     # 0x2b951
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
leaq 0x3ab(%rip), %rdx       # 0x6fa1
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbec5
movq 0x3037b(%rip), %rax     # 0x36f88
movq (%rax), %rdi
callq 0x6340
leaq 0x23dbf(%rip), %rcx     # 0x2a9db
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x70b9
movq 0x30343(%rip), %rax     # 0x36f78
movq (%rax), %rdi
callq 0x6340
leaq 0x23d9d(%rip), %rcx     # 0x2a9e1
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x70b9
movq 0x3039b(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
callq 0x6340
leaq 0x23d7c(%rip), %rcx     # 0x2a9e8
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x9, %r8d
callq 0x70b9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x706f
movq (%rdx), %r15
leaq -0x20(%rbp), %rdi
callq 0x6270
testl %eax, %eax
jne 0x709b
movl -0x20(%rbp), %esi
leaq 0x245ee(%rip), %rcx     # 0x2b5c3
movq %rbx, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x70b9
testq %rax, %rax
je 0x708b
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x2e36a(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7683
movl -0x1c(%rbp), %esi
leaq 0x2459a(%rip), %rcx     # 0x2b5c3
movq %rbx, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x70b9
testq %rax, %rax
je 0x708b
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7683
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x7067
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x70ab
leaq 0x2657b(%rip), %rcx     # 0x2d5f1
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
jmp 0x70ab
movl -0x20(%rbp), %edi
callq 0x6260
movl -0x1c(%rbp), %edi
callq 0x6260
movq %rbx, %rdi
xorl %esi, %esi
callq 0x148fa
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
leaq 0x2dddb(%rip), %r12     # 0x351c0
cmpq %r12, %rax
jne 0x73f0
cmpq %rbx, 0x18(%r14)
je 0x7438
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x7401
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x743d
movq 0x8(%r14), %rax
cmpq %r12, %rax
je 0x7434
testq %rax, %rax
je 0x7430
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7430
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r12, 0x8(%r14)
movq %rbx, 0x18(%r14)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x762e
movq %rax, %r14
testq %r15, %r15
je 0x748e
cmpb $0x0, (%r15)
je 0x748e
movq %rbx, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
incl 0x10(%r14)
leaq 0x2607b(%rip), %rdx     # 0x2d514
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0xeba5
movq %rax, %r15
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x74c7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
leaq 0x23aa9(%rip), %rsi     # 0x2af77
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6923
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
callq 0xae38
movq %rax, %rbx
cmpl $-0x1, %r14d
jne 0x7535
movq %r15, %rdi
callq 0x6180
movq %rax, %r14
testl %r14d, %r14d
je 0x7564
leal 0x1(%r14), %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x2fd3f(%rip)          # 0x37288
movq %rax, %r12
movslq %r14d, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6320
movb $0x0, (%r12,%r13)
jmp 0x756b
leaq 0x2fd2d(%rip), %r12     # 0x37298
movq %r12, (%rbx)
movl %r14d, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75b3
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x75b3
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x2fcd5(%rip), %rcx     # 0x37298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x75d5
xorl %esi, %esi
callq *0x2fcb3(%rip)          # 0x37288
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
testq %rcx, %rcx
je 0x75e6
movq %rax, 0x38(%rcx)
testq %rax, %rax
je 0x75ef
movq %rcx, 0x30(%rax)
cmpq %rbx, 0xb8(%r14)
jne 0x75ff
movq %rax, 0xb8(%r14)
movq $0x0, 0x30(%rbx)
movq 0xc0(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x761b
movq %rbx, 0x30(%rax)
movq %rbx, 0xc0(%r14)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xae38
movq %rax, %r15
leaq 0x2dd1b(%rip), %rax     # 0x35368
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
testl %r14d, %r14d
je 0x7675
movq %r15, %rdi
xorl %esi, %esi
movl %r14d, %edx
movq %rbx, %rcx
callq 0xe263
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListAppendElement
void Jim_ListAppendElement(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *objPtr)
{
    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendElement called with shared object"));
    SetListFromAny(interp, listPtr);
    Jim_InvalidateStringRep(listPtr);
    ListAppendElement(listPtr, objPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
callq 0xe2fe
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x2fbef(%rip), %rcx     # 0x37298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x76bb
xorl %esi, %esi
callq *0x2fbcd(%rip)          # 0x37288
movq $0x0, (%rbx)
leaq -0x18(%rbp), %rcx
movq %r14, (%rcx)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xe263
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d200(%rip), %rcx     # 0x352f0
cmpq %rcx, %rax
je 0x8170
leaq 0x2d2bc(%rip), %r13     # 0x353b8
cmpq %r13, %rax
je 0x81ef
movq %rdi, %r15
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x8119
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
cmpb $0x65, (%rsi)
jne 0x8191
cmpb $0x6e, 0x1(%rsi)
jne 0x8191
cmpb $0x64, 0x2(%rsi)
jne 0x8191
movq $0x0, -0x38(%rbp)
movzbl 0x3(%rsi), %eax
testl %eax, %eax
je 0x823f
cmpl $0x2d, %eax
je 0x814c
cmpl $0x2b, %eax
jne 0x81d4
addq $0x3, %rsi
movq %r15, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
testq %rax, %rax
je 0x8236
movq %rax, %r12
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x819b
movq 0x18(%r14), %rax
testq %rax, %rax
js 0x81f5
movq %rax, %rcx
shrq $0x1f, %rcx
je 0x821b
movl $0x7fffffff, (%rbx)     # imm = 0x7FFFFFFF
jmp 0x826a
movl $0x0, -0x2c(%rbp)
movq %r14, %r12
incl 0x10(%r12)
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xd7f8
movl %eax, %r13d
movl 0x10(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r12)
cmpl $0x1, %eax
jg 0x81cf
movq %r15, %rdi
movq %r12, %rsi
callq 0x758c
testl %r13d, %r13d
je 0x81fd
leaq 0x23ba1(%rip), %rsi     # 0x2bd7c
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
jmp 0x826c
movl 0x18(%r14), %r12d
jmp 0x8267
movl $0x80000001, (%rbx)     # imm = 0x80000001
jmp 0x826a
movq -0x38(%rbp), %rax
cmpb $0x0, -0x2c(%rbp)
je 0x821f
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
testq %rax, %rax
leaq 0x2d1a1(%rip), %r13     # 0x353b8
jg 0x8245
jmp 0x823f
movl %eax, (%rbx)
jmp 0x826a
testq %rax, %rax
movq $-0x7fffffff, %r12      # imm = 0x80000001
cmovnsq %rax, %r12
leaq 0x2d184(%rip), %r13     # 0x353b8
jmp 0x8245
xorl %eax, %eax
leaq 0x2d179(%rip), %r13     # 0x353b8
decq %rax
movq %rax, %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x825f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x825f
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_O3/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, %rbx
movq 0x8(%rsi), %rax
leaq 0x2da18(%rip), %rcx     # 0x35cb8
cmpq %rcx, %rax
je 0x82e6
movq (%r15), %r13
testq %r13, %r13
jne 0x82b6
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %r13
movl $0x68, %esi
xorl %edi, %edi
callq *0x2efc5(%rip)          # 0x37288
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x129c4
testl %eax, %eax
je 0x82fa
cmpl $0x13, %eax
jbe 0x8329
leaq 0x22fb8(%rip), %rcx     # 0x2b29c
jmp 0x8336
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x82a5
cmpl %r12d, 0x20(%r15)
jne 0x82a5
jmp 0x837e
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x8314
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x8314
movq %rbx, %rdi
movq %r15, %rsi
callq *%rax
leaq 0x2d99d(%rip), %rax     # 0x35cb8
movq %rax, 0x8(%r15)
movl %r12d, 0x20(%r15)
movq %r14, 0x18(%r15)
jmp 0x837e
movl %eax, %eax
leaq 0x2d5ee(%rip), %rcx     # 0x35920
movq (%rcx,%rax,8), %rcx
leaq 0x233e3(%rip), %rdx     # 0x2b720
leaq -0x90(%rbp), %r15
movl $0x64, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x61e0
leaq 0x23275(%rip), %rsi     # 0x2b5cf
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6923
movq 0x20(%r14), %rdi
callq 0x6040
movq %r14, %rdi
xorl %esi, %esi
callq *0x2ef0d(%rip)          # 0x37288
xorl %r14d, %r14d
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x83ad
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x83b8
movl 0x14(%rbx), %eax
movl %eax, (%r14)
movq (%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xae38
leaq 0x2cc66(%rip), %rcx     # 0x352f0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1c1
testl %eax, %eax
je 0x8839
cmpl $0x1, %eax
je 0x87bc
cmpl $0x64, %eax
jne 0x88db
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 0xc360
movl $0x18, %esi
xorl %edi, %edi
callq *0x2eabf(%rip)          # 0x37288
movq %rax, %r15
movq %r12, (%rax)
incl 0x10(%r12)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x87f8
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
cmpb $0x3a, (%rsi)
jne 0x886d
cmpb $0x3a, 0x1(%rsi)
jne 0x886d
movl 0x14(%r14), %edx
decl %edx
cmpb $0x3a, 0x1(%rsi)
leaq 0x1(%rsi), %rsi
je 0x8807
movq 0x60(%rbx), %r13
leaq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0x7508
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xa8a8
movl $0x1, %r12d
jmp 0x8883
movq 0x18(%r14), %r14
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x88ba
movq 0x58(%rbx), %r15
movq %rax, 0x58(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x876e
movl %eax, %ecx
movq %r15, 0x58(%rbx)
movl $0x1, %eax
testl %ecx, %ecx
jne 0x88dd
jmp 0x88db
movq 0x58(%rbx), %r13
leaq 0x10(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa8a8
xorl %r12d, %r12d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x889d
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x889d
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
leaq 0x2d4b4(%rip), %rax     # 0x35d58
movq %rax, 0x8(%r14)
movq (%r13), %rax
movq %rax, 0x20(%r14)
movq %r15, 0x18(%r14)
movl %r12d, 0x28(%r14)
jmp 0x88db
incl 0x10(%r12)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x88d8
movq %rbx, %rdi
callq 0x758c
movq %r12, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DuplicateObj
Jim_Obj *Jim_DuplicateObj(Jim_Interp *interp, Jim_Obj *objPtr)
{
    Jim_Obj *dupPtr;

    dupPtr = Jim_NewObj(interp);
    if (objPtr->bytes == NULL) {

        dupPtr->bytes = NULL;
    }
    else if (objPtr->length == 0) {
        dupPtr->bytes = JimEmptyStringRep;
        dupPtr->length = 0;
        dupPtr->typePtr = NULL;
        return dupPtr;
    }
    else {
        dupPtr->bytes = Jim_Alloc(objPtr->length + 1);
        dupPtr->length = objPtr->length;

        memcpy(dupPtr->bytes, objPtr->bytes, objPtr->length + 1);
    }


    dupPtr->typePtr = objPtr->typePtr;
    if (objPtr->typePtr != NULL) {
        if (objPtr->typePtr->dupIntRepProc == NULL) {
            dupPtr->internalRep = objPtr->internalRep;
        }
        else {

            objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr);
        }
    }
    return dupPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xae38
movq %rax, %rbx
cmpq $0x0, (%r14)
je 0x900e
movslq 0x14(%r14), %rsi
testq %rsi, %rsi
je 0x9038
incq %rsi
xorl %edi, %edi
callq *0x2e294(%rip)          # 0x37288
movq %rax, (%rbx)
movslq 0x14(%r14), %rdx
movl %edx, 0x14(%rbx)
movq (%r14), %rsi
incq %rdx
movq %rax, %rdi
callq 0x6320
jmp 0x9015
movq $0x0, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x9064
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x9053
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%rax
jmp 0x9064
leaq 0x2e259(%rip), %rax     # 0x37298
movq %rax, (%rbx)
movl $0x0, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x9064
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetVariable
Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
{
    if (interp->safeexpr) {
        return nameObjPtr;
    }
    switch (SetVariableFromAny(interp, nameObjPtr)) {
        case JIM_OK:{
                Jim_VarVal *vv = nameObjPtr->internalRep.varValue.vv;

                if (vv->linkFramePtr == NULL) {
                    return vv->objPtr;
                }
                else {
                    Jim_Obj *objPtr;


                    Jim_CallFrame *savedCallFrame = interp->framePtr;

                    interp->framePtr = vv->linkFramePtr;
                    objPtr = Jim_GetVariable(interp, vv->objPtr, flags);
                    interp->framePtr = savedCallFrame;
                    if (objPtr) {
                        return objPtr;
                    }

                }
            }
            break;

        case JIM_DICT_SUGAR:

            return JimDictSugarGet(interp, nameObjPtr, flags);
    }
    if (flags & JIM_ERRMSG) {
        Jim_SetResultFormatted(interp, "can't read \"%#s\": no such variable", nameObjPtr);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0xb0(%rdi)
je 0x9916
movq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %r15d
movq %rdi, %r14
movq %rbx, %rsi
callq 0xc1c1
cmpl $0x64, %eax
je 0x9967
testl %eax, %eax
jne 0x995c
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x99af
movq 0x58(%r14), %r13
movq %rcx, 0x58(%r14)
movq (%rax), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x98e7
movq %rax, %r12
movq %r13, 0x58(%r14)
testq %rax, %rax
jne 0x9904
testb $0x1, %r15b
jne 0x9993
xorl %r12d, %r12d
jmp 0x9904
movq %r14, %rdi
movq %rbx, %rsi
callq 0x186a9
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
movl %r15d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x187d5
leaq 0x213dc(%rip), %rsi     # 0x2ad76
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6923
jmp 0x9904
movq (%rax), %r12
jmp 0x9904
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictMerge
Jim_Obj *Jim_DictMerge(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
    Jim_Obj *objPtr = Jim_NewDictObj(interp, NULL, 0);
    int i;

    JimPanic((objc == 0, "Jim_DictMerge called with objc=0"));



    for (i = 0; i < objc; i++) {
        Jim_Obj **table;
        int tablelen;
        int j;

        table = Jim_DictPairs(interp, objv[i], &tablelen);
        if (tablelen && !table) {
            Jim_FreeNewObj(interp, objPtr);
            return NULL;
        }
        for (j = 0; j < tablelen; j += 2) {
            DictAddElement(interp, objPtr, table[j], table[j + 1]);
        }
    }
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x40(%rbp)
movl %esi, %r12d
movq %rdi, %r14
callq 0xae38
movq %rax, %rbx
leaq 0x2b9af(%rip), %rax     # 0x35390
movq %rax, 0x8(%rbx)
movq $0x0, (%rbx)
movl $0x30, %esi
xorl %edi, %edi
callq *0x2d88f(%rip)          # 0x37288
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rax, 0x18(%rbx)
testl %r12d, %r12d
jle 0x9a86
movl %r12d, %eax
movq %rax, -0x38(%rbp)
xorl %r15d, %r15d
movq -0x40(%rbp), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
leaq -0x2c(%rbp), %rdx
callq 0xf69a
movq %rax, %r13
movl -0x2c(%rbp), %r12d
testl %r12d, %r12d
je 0x9a3f
testq %r13, %r13
je 0x9a79
movq %r15, -0x48(%rbp)
testl %r12d, %r12d
jle 0x9a6a
xorl %r15d, %r15d
movq (%r13,%r15,8), %rdx
movq 0x8(%r13,%r15,8), %rcx
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xf26d
addq $0x2, %r15
cmpl %r15d, %r12d
jg 0x9a4b
movq -0x48(%rbp), %r15
incq %r15
cmpq -0x38(%rbp), %r15
jne 0x9a1a
jmp 0x9a86
movq %r14, %rdi
movq %rbx, %rsi
callq 0x758c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_PwdCmd
static int Jim_PwdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    char *cwd = Jim_Alloc(MAXPATHLEN);

    if (getcwd(cwd, MAXPATHLEN) == NULL) {
        Jim_SetResultString(interp, "Failed to get pwd", -1);
        Jim_Free(cwd);
        return JIM_ERR;
    }
    JimFixPath(cwd);
    Jim_SetResultString(interp, cwd, -1);

    Jim_Free(cwd);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1000, %esi           # imm = 0x1000
xorl %edi, %edi
callq *0x2d6c4(%rip)          # 0x37288
movq %rax, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
callq 0x6250
testq %rax, %rax
je 0x9c22
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r12
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x9c08
movq %rbx, %rdi
callq 0x758c
movq %r12, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq *0x2d672(%rip)          # 0x37288
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21be3(%rip), %rsi     # 0x2b80c
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r12
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movl $0x1, %r15d
cmpl $0x2, %eax
jl 0x9c00
jmp 0x9c08