LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/xf.c
// Function: main
void main()
{
  FATFS fs;
  FILINFO fn;
  FIL f;
  char buf[512];
  int r;
  FCHK(f_mount(&fs, "", 0)); 
  FCHK(f_open(&f, "/abc/a.txt", FA_READ));
  FCHK(f_read(&f, buf, 512, &r));
  FCHK(f_close(&f));
  printf("read %d\n", r);
  printf("read %s\n", buf);  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x700, %rsp            # imm = 0x700
leaq -0x258(%rbp), %rdi
leaq 0x6322(%rip), %rsi      # 0x74bb
xorl %edx, %edx
callq 0x1670
movl %eax, -0x6d8(%rbp)
movl -0x6d8(%rbp), %eax
movl %eax, -0x6f4(%rbp)
movl -0x6d8(%rbp), %edi
callq 0x1310
movl -0x6f4(%rbp), %edx
movq %rax, %rcx
leaq 0x5e87(%rip), %rdi      # 0x7054
leaq 0x5e93(%rip), %rsi      # 0x7067
movb $0x0, %al
callq 0x1040
leaq -0x4c8(%rbp), %rdi
leaq 0x5e92(%rip), %rsi      # 0x707b
movl $0x1, %edx
callq 0x2040
movl %eax, -0x6dc(%rbp)
movl -0x6dc(%rbp), %eax
movl %eax, -0x6f0(%rbp)
movl -0x6dc(%rbp), %edi
callq 0x1310
movl -0x6f0(%rbp), %edx
movq %rax, %rcx
leaq 0x5e34(%rip), %rdi      # 0x7054
leaq 0x5e5f(%rip), %rsi      # 0x7086
movb $0x0, %al
callq 0x1040
leaq -0x6d0(%rbp), %rsi
leaq -0x4c8(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
leaq -0x6d4(%rbp), %rcx
callq 0x2cc0
movl %eax, -0x6e0(%rbp)
movl -0x6e0(%rbp), %eax
movl %eax, -0x6ec(%rbp)
movl -0x6e0(%rbp), %edi
callq 0x1310
movl -0x6ec(%rbp), %edx
movq %rax, %rcx
leaq 0x5dda(%rip), %rdi      # 0x7054
leaq 0x5e27(%rip), %rsi      # 0x70a8
movb $0x0, %al
callq 0x1040
leaq -0x4c8(%rbp), %rdi
callq 0x3b80
movl %eax, -0x6e4(%rbp)
movl -0x6e4(%rbp), %eax
movl %eax, -0x6e8(%rbp)
movl -0x6e4(%rbp), %edi
callq 0x1310
movl -0x6e8(%rbp), %edx
movq %rax, %rcx
leaq 0x5d93(%rip), %rdi      # 0x7054
leaq 0x5df9(%rip), %rsi      # 0x70c1
movb $0x0, %al
callq 0x1040
movl -0x6d4(%rbp), %esi
leaq 0x5df1(%rip), %rdi      # 0x70cd
movb $0x0, %al
callq 0x1040
leaq -0x6d0(%rbp), %rsi
leaq 0x5de5(%rip), %rdi      # 0x70d6
movb $0x0, %al
callq 0x1040
addq $0x700, %rsp            # imm = 0x700
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/random_mixed/main.c
// Function: randommixed
static int
randommixed(struct wire_requestqueue * Q, uint64_t N)
{
	struct randommixed_state C;
	uint8_t buf[40];	/* dummy */

	/* Initialize. */
	C.Q = Q;
	C.Nip = 0;
	C.Nr = 0;
	C.Nmax = N;
	C.failed = 0;
	C.done = 0;

	/* Allocate key and value structures. */
	memset(buf, 0, 40);
	if ((C.key = kvldskey_create(buf, 40)) == NULL)
		goto err0;
	if ((C.val = kvldskey_create(buf, 40)) == NULL)
		goto err1;

	/* Prepare benchmark time handling. */
	if ((C.B = bench_init(BENCHMARK_START, BENCHMARK_SECONDS)) == NULL) {
		warn0("bench_init");
		goto err2;
	}

	/* Send an initial batch of 4096 requests. */
	if (sendbatch(&C))
		goto err3;

	/* Wait until we've finished. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		goto err3;
	}

	/* Print median number of operations performed in a single second. */
	printf("%" PRIu64 "\n", bench_median(C.B));

	/* Free the key and value structures. */
	bench_free(C.B);
	kvldskey_free(C.val);
	kvldskey_free(C.key);

	/* Success! */
	return (0);

err3:
	bench_free(C.B);
err2:
	kvldskey_free(C.val);
err1:
	kvldskey_free(C.key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x21a0
leaq -0x90(%rbp), %rdi
movl $0x28, %esi
callq 0x77e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2924
jmp 0x2a3a
leaq -0x90(%rbp), %rdi
movl $0x28, %esi
callq 0x77e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2944
jmp 0x2a31
movl $0x32, %edi
movl $0x64, %esi
callq 0x7010
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x297d
jmp 0x295f
leaq 0x1488b(%rip), %rdi     # 0x171f1
movb $0x0, %al
callq 0x6dd0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2a28
leaq -0x60(%rbp), %rdi
callq 0x2a50
cmpl $0x0, %eax
je 0x2990
jmp 0x2a1f
leaq -0x60(%rbp), %rdi
addq $0x2c, %rdi
callq 0x3010
cmpl $0x0, %eax
jne 0x29a8
cmpl $0x0, -0x38(%rbp)
je 0x29e1
jmp 0x29aa
callq 0x20a0
cmpl $0x0, (%rax)
je 0x29cf
leaq 0x14841(%rip), %rdi     # 0x171fc
movb $0x0, %al
callq 0x6b80
callq 0x20a0
movl $0x0, (%rax)
jmp 0x29dd
leaq 0x14826(%rip), %rdi     # 0x171fc
movb $0x0, %al
callq 0x6dd0
jmp 0x29df
jmp 0x2a1f
movq -0x20(%rbp), %rdi
callq 0x7480
movq %rax, %rsi
leaq 0x1481b(%rip), %rdi     # 0x1720f
movb $0x0, %al
callq 0x2160
movq -0x20(%rbp), %rdi
callq 0x75a0
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x2a41
movq -0x20(%rbp), %rdi
callq 0x75a0
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/random_mixed/main.c
// Function: sendbatch
static int
sendbatch(struct randommixed_state * C)
{
	unsigned long N;
	uint64_t X, Y;

	while (C->Nip < 4096) {
		/* Generate a random key. */
		N = (size_t)random() % C->Nmax;
		X = N >> 16;
		Y = N - (X << 16);
		mkkey(X, Y, C->key->buf);

		/* Send the request. */
		if ((C->Nr++) & 2) {
			be64enc(C->val->buf, C->Nr);
			if (proto_kvlds_request_set(C->Q, C->key, C->val,
			    callback_done, C))
				goto err0;
		} else {
			if (proto_kvlds_request_get(C->Q, C->key,
			    callback_get, C))
				goto err0;
		}
		C->Nip += 1;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1000, 0x10(%rax)     # imm = 0x1000
jae 0x2b5c
callq 0x2220
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x10, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
addq $0x1, %rdx
callq 0x75e0
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rcx)
andq $0x2, %rax
cmpq $0x0, %rax
je 0x2b1f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2b80
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %r8
leaq 0x13f(%rip), %rcx       # 0x2c50
callq 0x7c30
cmpl $0x0, %eax
je 0x2b1d
jmp 0x2b65
jmp 0x2b47
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rcx
leaq 0x1e7(%rip), %rdx       # 0x2d20
callq 0x87a0
cmpl $0x0, %eax
je 0x2b45
jmp 0x2b65
jmp 0x2b47
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2a5c
movl $0x0, -0x4(%rbp)
jmp 0x2b6c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro7/macro7.c
// Function: endOfBinary
void endOfBinary()
{
  punchLiteralPool( &cp, clc - 1 );
  if( start_addr >= 0)
  {
    punchTriplet( JMP | ( start_addr & 017777 ));
    punchTriplet( 0 );
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8ee6(%rip), %esi      # 0xd3a0
subl $0x1, %esi
leaq 0x8ef4(%rip), %rdi      # 0xd3b8
callq 0x66c0
cmpl $0x0, 0x8ed4(%rip)      # 0xd3a4
jl 0x44f0
movl 0x8ecc(%rip), %edi      # 0xd3a4
andl $0x1fff, %edi           # imm = 0x1FFF
orl $0x30000, %edi          # imm = 0x30000
callq 0x6760
xorl %edi, %edi
callq 0x6760
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro7/macro7.c
// Function: insertLiteral
WORD32 insertLiteral( LPOOL_T *p, WORD32 pool_page, WORD32 value )
{
  WORD32  ix;

  /* Search the literal pool for any occurence of the needed value.           */
  ix = LIT_BASE - 1;
  while( ix >= lit_loc && p->pool[ix] != value )
  {
    ix--;
  }

  /* Check if value found in literal pool. If not, then insert value.         */
  if( ix < lit_loc )
  {
    lit_loc--;
    p->pool[lit_loc] = value;
    ix = lit_loc;
  }
  return( ix );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1eff, -0x14(%rbp)    # imm = 0x1EFF
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl 0x7698(%rip), %ecx      # 0xd3a8
movb %al, -0x15(%rbp)
jl 0x5d2a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5d33
jmp 0x5d3e
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5d05
movl -0x14(%rbp), %eax
cmpl 0x7661(%rip), %eax      # 0xd3a8
jge 0x5d73
movl 0x7659(%rip), %eax      # 0xd3a8
addl $-0x1, %eax
movl %eax, 0x7650(%rip)      # 0xd3a8
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq 0x7642(%rip), %rcx      # 0xd3a8
movl %edx, 0x4(%rax,%rcx,4)
movl 0x7638(%rip), %eax      # 0xd3a8
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro7/macro7.c
// Function: testForLiteralCollision
BOOL testForLiteralCollision( WORD32 loc )
{
  WORD32  pagelc;
  BOOL    result = FALSE;

  pagelc  = loc & ADDRESS_FIELD;
  if( ( pagelc >= lit_loc ) && ( lit_loc != LIT_BASE ) && !cp.error )
  {
    errorMessage( &literal_overflow, -1 );
    cp.error = TRUE;
    result = TRUE;
  }
  return( result );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb $0x0, -0x9(%rbp)
movl -0x4(%rbp), %eax
andl $0x1fff, %eax           # imm = 0x1FFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x7075(%rip), %eax      # 0xd3a8
jl 0x6369
cmpl $0x1f00, 0x7069(%rip)   # imm = 0x1F00
je 0x6369
cmpl $0x0, 0x7070(%rip)      # 0xd3b8
jne 0x6369
leaq 0x4b3f(%rip), %rdi      # 0xae90
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6200
movl $0x1, 0x7053(%rip)      # 0xd3b8
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro7/macro7.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, WORD32 lpool_page )
{
  WORD32  loc;
  WORD32  tmplc;

  if( lit_loc < LIT_BASE )
  {
    for( loc = lit_loc; loc < LIT_BASE; loc++ )
    {
      tmplc = loc + ( lpool_page & 060000 );
      printLine( line, tmplc, p->pool[loc], LOC_VAL );
      punchLocObject( tmplc, p->pool[loc] );
    }
    p->error = FALSE;
    lit_loc = LIT_BASE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1f00, 0x6ccf(%rip)   # imm = 0x1F00
jge 0x6751
movl 0x6cc7(%rip), %eax      # 0xd3a8
movl %eax, -0x10(%rbp)
cmpl $0x1f00, -0x10(%rbp)    # imm = 0x1F00
jge 0x673d
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
andl $0x6000, %ecx           # imm = 0x6000
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %edx
leaq 0xe8cc(%rip), %rdi      # 0x14fe0
movl $0x3, %ecx
callq 0x4870
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %esi
callq 0x6800
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x66e4
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x1f00, 0x6c57(%rip)   # imm = 0x1F00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxEnv.c
// Function: HaxSetupEnv
void
HaxSetupEnv(
    Hax_Interp *interp,		/* Interpreter whose "env" array is to be
				 * managed. */
    UnixClientData *unixClientData	/* Unix Client Data */)
{
    Hax_Memoryp *memoryp;
    int i;

    /*
     * First, initialize our environment-related information, if
     * necessary.
     */

    if (unixClientData->environSize != 0) {
	Hax_Panic ((char *) "Unexpected initialized environ");
    }

    EnvInit(interp, unixClientData);

    /*
     * Next, get the pointer to Memoryp.
     */

    memoryp = Hax_GetMemoryp(interp);

    /*
     * Store the environment variable values into the interpreter's
     * "env" array, and arrange for us to be notified on future
     * writes and unsets to that array.
     */

    (void) Hax_UnsetVar2(interp, (char *) "env", (char *) NULL, HAX_GLOBAL_ONLY);
    for (i = 0; ; i++) {
	char *p, *p2;

	p = unixClientData->haxEnviron[i];
	if (p == NULL) {
	    break;
	}
	for (p2 = p; *p2 != '='; p2++) {
	    /* Empty loop body. */
	}
	*p2 = 0;
	(void) Hax_SetVar2(interp, (char *) "env", p, p2+1, HAX_GLOBAL_ONLY);
	*p2 = '=';
    }
    Hax_TraceVar2(interp, (char *) "env", (char *) NULL,
	    HAX_GLOBAL_ONLY | HAX_TRACE_WRITES | HAX_TRACE_UNSETS,
	    EnvTraceProc, (ClientData) unixClientData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x3758
leaq 0x78af(%rip), %rdi      # 0xb000
movb $0x0, %al
callq 0x3130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3840
movq -0x8(%rbp), %rdi
callq 0x3540
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x78a2(%rip), %rsi      # 0xb01f
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x3210
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x37af
jmp 0x380e
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x37d3
jmp 0x37c5
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x37b7
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
leaq 0x782e(%rip), %rsi      # 0xb01f
movl $0x1, %r8d
callq 0x30c0
movq -0x30(%rbp), %rax
movb $0x3d, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3792
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r9
leaq 0x7802(%rip), %rsi      # 0xb01f
xorl %eax, %eax
movl %eax, %edx
movl $0x61, %ecx
leaq 0x163(%rip), %r8        # 0x3990
callq 0x31a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxEnv.c
// Function: EnvInit
static void
EnvInit(
    Hax_Interp *interp,
    UnixClientData *unixClientData)
{
    Hax_Memoryp *memoryp;
    int i, length;

    if (unixClientData->environSize != 0) {
	Hax_Panic ((char *) "Unexpected double initialization of environ");
    }

    memoryp = Hax_GetMemoryp(interp);

    for (length = 0; environ[length] != NULL; length++) {
	/* Empty loop body. */
    }
    unixClientData->environSize = length+5;
    unixClientData->haxEnviron = (char **) ckalloc(memoryp,
		unixClientData->environSize * sizeof(char *));
    for (i = 0; i < length; i++) {
	unixClientData->haxEnviron[i] = (char *) ckalloc(memoryp,
		strlen(environ[i]) + 1);
	strcpy(unixClientData->haxEnviron[i], environ[i]);
    }
    unixClientData->haxEnviron[length] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x3868
leaq 0x785b(%rip), %rdi      # 0xb0bc
movb $0x0, %al
callq 0x3130
movq -0x8(%rbp), %rdi
callq 0x3540
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq 0xa755(%rip), %rax      # 0xdfd8
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x389e
jmp 0x3893
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x387c
movl -0x20(%rbp), %ecx
addl $0x5, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x60(%rax), %rsi
shlq $0x3, %rsi
leaq 0x7782(%rip), %rdx      # 0xb044
movl $0x1ff, %ecx            # imm = 0x1FF
callq 0x34c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x396d
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xa6df(%rip), %rax      # 0xdfd8
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3190
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
leaq 0x7729(%rip), %rdx      # 0xb044
movl $0x202, %ecx            # imm = 0x202
callq 0x34c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0xa689(%rip), %rax      # 0xdfd8
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x30e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x38de
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxEnv.c
// Function: Hax_FindVariable
int
Hax_FindVariable(
    ClientData clientData,	/* Unix Client Data */
    char *name,			/* Name of desired environment variable. */
    int *lengthPtr		/* Used to return length of name (for
				 * successful searches) or number of non-NULL
				 * entries in environ (for unsuccessful
				 * searches). */)
{
    UnixClientData *unixClientData = (UnixClientData *) clientData;
    int i;
    const char *p1, *p2;

    if (unixClientData->environSize == 0) {
	Hax_Panic ((char *) "Unexpected uninitialized environ");
    }

    for (i = 0, p1 = unixClientData->haxEnviron[i]; p1 != NULL; i++,
	p1 = unixClientData->haxEnviron[i]) {
	for (p2 = name; *p2 == *p1; p1++, p2++) {
	    /* NULL loop body. */
	}
	if ((*p1 == '=') && (*p2 == '\0')) {
	    *lengthPtr = p2-name;
	    return i;
	}
    }
    *lengthPtr = i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x3b64
leaq 0x74c6(%rip), %rdi      # 0xb023
movb $0x0, %al
callq 0x3130
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3c17
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
movq -0x38(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x3bc0
jmp 0x3ba6
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3b92
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x3bf3
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3bf3
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c27
jmp 0x3bf5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x3b7f
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxEnv.c
// Function: Hax_PutEnv
int
Hax_PutEnv(
    Hax_Interp *interp,
    ClientData clientData,	/* Unix Client Data */
    char *string		/* Info about environment variable in the
				 * form NAME=value. */)
{
    UnixClientData *unixClientData = (UnixClientData *) clientData;
    Hax_Memoryp *memoryp;
    int nameLength;
    char *name, *value;

    if (unixClientData->environSize == 0) {
	Hax_Panic ((char *) "Unexpected uninitialized environ");
    }

    if (string == NULL || strchr(name, '=') == NULL || string[0] == '=' ||
	strchr(strchr(name, '='), '=') != NULL /* two '=' detected */ ) {
	Hax_AppendResult(interp, "bad args: should be \""
                " NAME=value\"", (char *) NULL);
	return HAX_ERROR;
    }

    memoryp = Hax_GetMemoryp(interp);

    /*
     * Separate the string into name and value parts, then call
     * setenv to do all of the real work.
     */

    value = strchr(string, '=');
    if (value == NULL) {
	return 0;
    }
    nameLength = value - string;
    if (nameLength == 0) {
	return 0;
    }
    name = (char *) ckalloc(memoryp, nameLength+1);
    memcpy(name, string, nameLength);
    name[nameLength] = 0;
    Hax_SetEnv(interp, clientData, name, value+1, 1);
    ckfree(memoryp, name);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x3eb4
leaq 0x7176(%rip), %rdi      # 0xb023
movb $0x0, %al
callq 0x3130
cmpq $0x0, -0x20(%rbp)
je 0x3efc
movq -0x40(%rbp), %rdi
movl $0x3d, %esi
callq 0x31e0
cmpq $0x0, %rax
je 0x3efc
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x3efc
movq -0x40(%rbp), %rdi
movl $0x3d, %esi
callq 0x31e0
movq %rax, %rdi
movl $0x3d, %esi
callq 0x31e0
cmpq $0x0, %rax
je 0x3f1e
movq -0x10(%rbp), %rdi
leaq 0x7146(%rip), %rsi      # 0xb04d
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x3feb
movq -0x10(%rbp), %rdi
callq 0x3540
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3d, %esi
callq 0x31e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3f50
movl $0x0, -0x4(%rbp)
jmp 0x3feb
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3f6d
movl $0x0, -0x4(%rbp)
jmp 0x3feb
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
leaq 0x70c3(%rip), %rdx      # 0xb044
movl $0x141, %ecx            # imm = 0x141
callq 0x34c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x33c0
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
addq $0x1, %rcx
movl $0x1, %r8d
callq 0x3620
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x706a(%rip), %rdx      # 0xb044
movl $0x145, %ecx            # imm = 0x145
callq 0x31f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxEnv.c
// Function: Hax_UnsetEnv
int
Hax_UnsetEnv(
    Hax_Interp *interp,
    ClientData clientData,		/* Unix Client Data */
    char *name				/* Name of variable to remove. */)
{
    UnixClientData *unixClientData = (UnixClientData *) clientData;
    Hax_Memoryp *memoryp;
    int index, dummy;
    char **envPtr;

    if (unixClientData->environSize == 0) {
	Hax_Panic ((char *) "Unexpected uninitialized environ");
    }

    if (name == NULL || strchr(name, '=') != NULL) {
	Hax_AppendResult(interp, "invalid name: should be \""
                " name\"", (char *) NULL);
	return HAX_ERROR;
    }

    memoryp = Hax_GetMemoryp(interp);

    /*
     * Update the environ array.
     */

    index = Hax_FindVariable((ClientData) unixClientData, name, &dummy);
    if (index == -1) {
	return HAX_OK;
    }
    ckfree(memoryp, unixClientData->haxEnviron[index]);
    for (envPtr = unixClientData->haxEnviron+index+1; ; envPtr++) {
	envPtr[-1] = *envPtr;
	if (*envPtr == NULL) {
	    break;
	}
    }

    (void) Hax_UnsetVar2(interp, (char *) "env", (char *) name,
	HAX_GLOBAL_ONLY);

    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x4034
leaq 0x6ff6(%rip), %rdi      # 0xb023
movb $0x0, %al
callq 0x3130
cmpq $0x0, -0x20(%rbp)
je 0x404f
movq -0x20(%rbp), %rdi
movl $0x3d, %esi
callq 0x31e0
cmpq $0x0, %rax
je 0x4071
movq -0x10(%rbp), %rdi
leaq 0x7015(%rip), %rsi      # 0xb06f
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x412f
movq -0x10(%rbp), %rdi
callq 0x3540
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3330
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x40a4
movl $0x0, -0x4(%rbp)
jmp 0x412f
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6f85(%rip), %rdx      # 0xb044
movl $0x179, %ecx            # imm = 0x179
callq 0x31f0
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x34(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x8(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x40ff
jmp 0x410f
jmp 0x4101
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x40e4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6f01(%rip), %rsi      # 0xb01f
movl $0x1, %ecx
callq 0x3210
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxEnv.c
// Function: Hax_EnvTraceProc
void
Hax_EnvTraceProc(
    Hax_Interp *interp,
    ClientData clientData,
    Hax_EnvWriteProc *writeProc,
    Hax_EnvUnsetProc *unsetProc,
    Hax_EnvDestroyProc *destroyProc)
{
    UnixClientData *unixClientData = (UnixClientData *) clientData;

    unixClientData->writeProc = writeProc;
    unixClientData->unsetProc = unsetProc;
    unixClientData->destroyProc = destroyProc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x80(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_CdCmd
int
Hax_CdCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    Hax_Memoryp *memoryp;
    char *dirName;

    memoryp = Hax_GetMemoryp(interp);
    clientDataPtr = (UnixClientData *) clientData;

    if (argc > 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" dirName\"", (char *) NULL);
	return HAX_ERROR;
    }

    if (argc == 2) {
	dirName = argv[1];
    } else {
	dirName = (char *) "~";
    }
    dirName = Hax_TildeSubst(interp, clientData, dirName);
    if (dirName == NULL) {
	return HAX_ERROR;
    }
    if (clientDataPtr->currentDir != NULL) {
	ckfree(memoryp, clientDataPtr->currentDir);
	clientDataPtr->currentDir = NULL;
    }
    if (chdir(dirName) != 0) {
	Hax_AppendResult(interp, "couldn't change working directory to \"",
		dirName, "\": ", Hax_UnixError(interp), (char *) NULL);
	return HAX_ERROR;
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3540
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, -0x1c(%rbp)
jle 0x4fb3
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x61af(%rip), %rsi      # 0xb143
leaq 0x6264(%rip), %rcx      # 0xb1ff
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x508a
cmpl $0x2, -0x1c(%rbp)
jne 0x4fc7
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x4fd2
leaq 0x623b(%rip), %rax      # 0xb209
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3570
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x4ffa
movl $0x1, -0x4(%rbp)
jmp 0x508a
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x502e
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x61f3(%rip), %rdx      # 0xb20b
movl $0x79, %ecx
callq 0x31f0
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x40(%rbp), %rdi
callq 0x31c0
cmpl $0x0, %eax
je 0x5083
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31b0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %r8
leaq 0x61b0(%rip), %rsi      # 0xb217
leaq 0x617d(%rip), %rcx      # 0xb1eb
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x508a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_EofCmd
int
Hax_EofCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    OpenFile *filePtr;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileId\"", (char *) NULL);
	return HAX_ERROR;
    }

    clientDataPtr = (UnixClientData *) clientData;
    if (HaxGetOpenFile(interp, clientDataPtr, argv[1], &filePtr) != HAX_OK) {
	return HAX_ERROR;
    }
    if (feof(filePtr->f)) {
	interp->result = (char *) "1";
    } else {
	interp->result = (char *) "0";
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x569b
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x5ac4(%rip), %rsi      # 0xb143
leaq 0x5fcc(%rip), %rcx      # 0xb652
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x5700
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rcx
callq 0x3060
cmpl $0x0, %eax
je 0x56ca
movl $0x1, -0x4(%rbp)
jmp 0x5700
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x3370
cmpl $0x0, %eax
je 0x56eb
movq -0x18(%rbp), %rax
leaq 0x6ad3(%rip), %rcx      # 0xc1b9
movq %rcx, (%rax)
jmp 0x56f9
movq -0x18(%rbp), %rax
leaq 0x5b58(%rip), %rcx      # 0xb24e
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_ExitCmd
int
Hax_ExitCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int value;

    if ((argc != 1) && (argc != 2)) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" ?returnCode?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (argc == 1) {
	exit(0);
    }
    if (Hax_GetInt(interp, argv[1], &value) != HAX_OK) {
	return HAX_ERROR;
    }
    exit(value);
    return HAX_OK;			/* Better not ever reach this! */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x5991
cmpl $0x2, -0x1c(%rbp)
je 0x5991
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x57ce(%rip), %rsi      # 0xb143
leaq 0x58f5(%rip), %rcx      # 0xb271
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x59c9
cmpl $0x1, -0x1c(%rbp)
jne 0x599e
xorl %edi, %edi
callq 0x35b0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x3180
cmpl $0x0, %eax
je 0x59c1
movl $0x1, -0x4(%rbp)
jmp 0x59c9
movl -0x2c(%rbp), %edi
callq 0x35b0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: GetFileType
static char *
GetFileType(
    int mode)
{
    if (S_ISREG(mode)) {
	return (char *) "file";
    } else if (S_ISDIR(mode)) {
	return (char *) "directory";
    } else if (S_ISCHR(mode)) {
	return (char *) "characterSpecial";
    } else if (S_ISBLK(mode)) {
	return (char *) "blockSpecial";
    } else if (S_ISFIFO(mode)) {
	return (char *) "fifo";
    } else if (S_ISLNK(mode)) {
	return (char *) "link";
    } else if (S_ISSOCK(mode)) {
	return (char *) "socket";
    }
    return (char *) "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x6a86
leaq 0x561d(%rip), %rax      # 0xc09a
movq %rax, -0x8(%rbp)
jmp 0x6b4b
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x6aa5
leaq 0x4843(%rip), %rax      # 0xb2df
movq %rax, -0x8(%rbp)
jmp 0x6b4b
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x6ac4
leaq 0x4c90(%rip), %rax      # 0xb74b
movq %rax, -0x8(%rbp)
jmp 0x6b4b
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x6000, %eax           # imm = 0x6000
jne 0x6ae0
leaq 0x4c82(%rip), %rax      # 0xb75c
movq %rax, -0x8(%rbp)
jmp 0x6b4b
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x6afc
leaq 0x4c73(%rip), %rax      # 0xb769
movq %rax, -0x8(%rbp)
jmp 0x6b4b
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0x6b18
leaq 0x481a(%rip), %rax      # 0xb32c
movq %rax, -0x8(%rbp)
jmp 0x6b4b
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xc000, %eax           # imm = 0xC000
jne 0x6b34
leaq 0x4c40(%rip), %rax      # 0xb76e
movq %rax, -0x8(%rbp)
jmp 0x6b4b
jmp 0x6b36
jmp 0x6b38
jmp 0x6b3a
jmp 0x6b3c
jmp 0x6b3e
jmp 0x6b40
leaq 0x4c2e(%rip), %rax      # 0xb775
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_FlushCmd
int
Hax_FlushCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    OpenFile *filePtr;
    FILE *f;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileId\"", (char *) NULL);
	return HAX_ERROR;
    }

    clientDataPtr = (UnixClientData *) clientData;
    if (HaxGetOpenFile(interp, clientDataPtr, argv[1], &filePtr) != HAX_OK) {
	return HAX_ERROR;
    }
    if (!filePtr->writable) {
	Hax_AppendResult(interp, "\"", argv[1],
		"\" wasn't opened for writing", (char *) NULL);
	return HAX_ERROR;
    }
    f = filePtr->f2;
    if (f == NULL) {
	f = filePtr->f;
    }
    if (fflush(f) == EOF) {
	Hax_AppendResult(interp, "error flushing \"", argv[1],
		"\": ", Hax_UnixError(interp), (char *) NULL);
	clearerr(f);
	return HAX_ERROR;
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x6bae
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x45b4(%rip), %rsi      # 0xb143
leaq 0x4abc(%rip), %rcx      # 0xb652
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x6ca3
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rcx
callq 0x3060
cmpl $0x0, %eax
je 0x6be0
movl $0x1, -0x4(%rbp)
jmp 0x6ca3
movq -0x38(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x6c1c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x4523(%rip), %rsi      # 0xb120
leaq 0x4825(%rip), %rcx      # 0xb429
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x6ca3
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6c3a
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3420
cmpl $-0x1, %eax
jne 0x6c9c
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31b0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %r8
leaq 0x47ce(%rip), %rsi      # 0xb445
leaq 0x456d(%rip), %rcx      # 0xb1eb
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x3510
movq -0x40(%rbp), %rdi
callq 0x33a0
movl $0x1, -0x4(%rbp)
jmp 0x6ca3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_PwdCmd
int
Hax_PwdCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Hax_Memoryp *memoryp;
    UnixClientData *clientDataPtr;
    char buffer[MAXPATHLEN+1];

    memoryp = Hax_GetMemoryp(interp);
    clientDataPtr = (UnixClientData *) clientData;

    if (argc != 1) {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], "\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (clientDataPtr->currentDir == NULL) {
	if (getcwd(buffer, MAXPATHLEN) == NULL) {
	    if (errno == ERANGE) {
		interp->result = (char *) "working directory name is too long";
	    } else {
		Hax_AppendResult(interp,
			"error getting working directory name: ",
			Hax_UnixError(interp), (char *) NULL);
	    }
	    return HAX_ERROR;
	}
	clientDataPtr->currentDir = (char *) ckalloc(memoryp, (unsigned)
		(strlen(buffer) + 1));
	strcpy(clientDataPtr->currentDir, buffer);
    }
    interp->result = clientDataPtr->currentDir;
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1050, %rsp           # imm = 0x1050
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3540
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x75b6
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x3bac(%rip), %rsi      # 0xb143
leaq 0x3b82(%rip), %rcx      # 0xb120
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x769b
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x7685
leaq -0x1040(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3280
cmpq $0x0, %rax
jne 0x762f
callq 0x3080
cmpl $0x22, (%rax)
jne 0x75f6
movq -0x18(%rbp), %rax
leaq 0x3f88(%rip), %rcx      # 0xb579
movq %rcx, (%rax)
jmp 0x7626
movq -0x18(%rbp), %rax
movq %rax, -0x1048(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31b0
movq -0x1048(%rbp), %rdi
movq %rax, %rdx
leaq 0x3f81(%rip), %rsi      # 0xb59c
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x769b
movq -0x30(%rbp), %rax
movq %rax, -0x1050(%rbp)
leaq -0x1040(%rbp), %rdi
callq 0x3190
movq -0x1050(%rbp), %rdi
addq $0x1, %rax
movl %eax, %eax
movl %eax, %esi
leaq 0x3baf(%rip), %rdx      # 0xb20b
movl $0x4cb, %ecx            # imm = 0x4CB
callq 0x34c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x1040(%rbp), %rsi
callq 0x30e0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1050, %rsp           # imm = 0x1050
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_SourceCmd
int
Hax_SourceCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileName\"", (char *) NULL);
	return HAX_ERROR;
    }
    return Hax_EvalFile(interp, clientData, argv[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x7f6b
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x31f4(%rip), %rsi      # 0xb143
leaq 0x376b(%rip), %rcx      # 0xb6c1
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x7f83
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x3390
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_TellCmd
int
Hax_TellCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    OpenFile *filePtr;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileId\"", (char *) NULL);
	return HAX_ERROR;
    }

    clientDataPtr = (UnixClientData *) clientData;
    if (HaxGetOpenFile(interp, clientDataPtr, argv[1], &filePtr) != HAX_OK) {
	return HAX_ERROR;
    }
    sprintf(interp->result, "%lld", (long long int) ftello(filePtr->f));
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x7fdb
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x3184(%rip), %rsi      # 0xb143
leaq 0x368c(%rip), %rcx      # 0xb652
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3510
movl $0x1, -0x4(%rbp)
jmp 0x803d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rcx
callq 0x3060
cmpl $0x0, %eax
je 0x800a
movl $0x1, -0x4(%rbp)
jmp 0x803d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x369d(%rip), %rsi      # 0xb6cc
movb $0x0, %al
callq 0x35a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_InitUnixCore
ClientData
Hax_InitUnixCore(
    Hax_Interp *interp)
{
    Hax_Memoryp *memoryp;
    CmdInfo *cmdInfoPtr;
    UnixClientData *clientDataPtr;
    char *libraryPath;

    memoryp = Hax_GetMemoryp(interp);

    clientDataPtr = (UnixClientData *) ckalloc(memoryp, sizeof(UnixClientData));
    clientDataPtr->numFiles = 0;
    clientDataPtr->filePtrArray = NULL;
    clientDataPtr->refCount = 0;
    clientDataPtr->currentDir = NULL;
    memset(&clientDataPtr->staticBuf, 0, sizeof(clientDataPtr->staticBuf));
    clientDataPtr->curSize = STATIC_BUF_SIZE;
    clientDataPtr->curBuf = clientDataPtr->staticBuf;
    clientDataPtr->environSize = 0;
    clientDataPtr->haxEnviron = NULL;
    clientDataPtr->waitTable = NULL;
    clientDataPtr->waitTableSize = 0;
    clientDataPtr->waitTableUsed = 0;

    for (cmdInfoPtr = builtInCmds; cmdInfoPtr->name != NULL;
	 cmdInfoPtr++) {
	Hax_CreateCommand (interp, (char *) cmdInfoPtr->name,
	                   cmdInfoPtr->proc, (ClientData) clientDataPtr,
	                   Hax_UnixCoreDelete);

	clientDataPtr->refCount++;
    }

    libraryPath = getenv("HAX_LIBRARY");
    if (libraryPath != NULL) {
	Hax_SetLibraryPath(interp, libraryPath);
    }

    HaxSetupEnv(interp, clientDataPtr);

    return (ClientData) clientDataPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3540
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x98, %esi
leaq 0x2da2(%rip), %rdx      # 0xb20b
movl $0x756, %ecx            # imm = 0x756
callq 0x34c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x3250
movq -0x20(%rbp), %rax
movl $0x32, 0x54(%rax)
movq -0x20(%rbp), %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x94(%rax)
leaq 0x5e24(%rip), %rax      # 0xe340
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8568
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq 0x5a98(%rip), %r8       # 0xdfe0
callq 0x3030
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x8520
leaq 0x31af(%rip), %rdi      # 0xb71e
callq 0x3050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x858c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3040
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3410
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUnixUtil.c
// Function: Hax_UnixError
char *
Hax_UnixError(
    Hax_Interp *interp		/* Interpreter whose $errorCode variable
				 * is to be changed. */)
{
    char *id, *msg;

    id = Hax_ErrnoId();
    msg = strerror(errno);
    Hax_SetErrorCode(interp, "UNIX", id, msg, (char *) NULL);
    return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x34b0
movq %rax, -0x10(%rbp)
callq 0x3080
movl (%rax), %edi
callq 0x35d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x30a5(%rip), %rsi      # 0xc50d
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3490
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop