LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdIL.c
// Function: Hax_LsortCmd
int
Hax_LsortCmd(
    ClientData notUsed,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int listArgc;
    char **listArgv;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" list\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (Hax_SplitList(interp, argv[1], &listArgc, &listArgv) != HAX_OK) {
	return HAX_ERROR;
    }
    qsort(listArgv, listArgc, sizeof (char *), SortCompareProc);
    interp->result = Hax_Merge(interp, listArgc, listArgv);
    interp->freeProc = (Hax_FreeProc *) free;
    ckfree(memoryp, (char *) listArgv);
    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), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0xc8b5
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x110de(%rip), %rsi     # 0x1d974
leaq 0x11747(%rip), %rcx     # 0x1dfe4
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xc93e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x3c(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x4520
cmpl $0x0, %eax
je 0xc8dc
movl $0x1, -0x4(%rbp)
jmp 0xc93e
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
movl $0x8, %edx
leaq 0x60(%rip), %rcx        # 0xc950
callq 0x4110
movq -0x18(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x48(%rbp), %rdx
callq 0x4510
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x1668e(%rip), %rcx     # 0x22fa8
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq 0x1167c(%rip), %rdx     # 0x1dfa9
movl $0x48b, %ecx            # imm = 0x48B
callq 0x4260
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdMZ.c
// Function: Hax_ReturnCmd
int
Hax_ReturnCmd(
    ClientData dummy,			/* Not used. */
    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],
		" ?value?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (argc == 2) {
	Hax_SetResult(interp, argv[1], HAX_VOLATILE);
    }
    return HAX_RETURN;
}

// 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)
jle 0xd7fb
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x10195(%rip), %rsi     # 0x1d974
leaq 0x10bcb(%rip), %rcx     # 0x1e3b1
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xd820
cmpl $0x2, -0x1c(%rbp)
jne 0xd819
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq $-0x1, %rdx
callq 0x44e0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdMZ.c
// Function: Hax_WhileCmd
int
Hax_WhileCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int result, value;

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

    while (1) {
	result = Hax_ExprBoolean(interp, argv[1], &value);
	if (result != HAX_OK) {
	    return result;
	}
	if (!value) {
	    break;
	}
	result = Hax_Eval(interp, NULL, argv[2], 0, (char **) NULL);
	if (result == HAX_CONTINUE) {
	    result = HAX_OK;
	} else if (result != HAX_OK) {
	    if (result == HAX_ERROR) {
		char msg[60];
		sprintf(msg, "\n    (\"while\" body line %d)",
			interp->errorLine);
		Hax_AddErrorInfo(interp, msg);
	    }
	    break;
	}
    }
    if (result == HAX_BREAK) {
	result = HAX_OK;
    }
    if (result == HAX_OK) {
	Hax_ResetResult(interp);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0xf93e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0xe055(%rip), %rsi      # 0x1d974
leaq 0xedf2(%rip), %rcx      # 0x1e718
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xf9fb
jmp 0xf940
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4640
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xf969
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf9fb
cmpl $0x0, -0x30(%rbp)
jne 0xf971
jmp 0xf9d9
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rsi
callq 0x45b0
movl %eax, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jne 0xf99e
movl $0x0, -0x2c(%rbp)
jmp 0xf9d4
cmpl $0x0, -0x2c(%rbp)
je 0xf9d2
cmpl $0x1, -0x2c(%rbp)
jne 0xf9d0
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0xed6b(%rip), %rsi      # 0x1e727
movb $0x0, %al
callq 0x45d0
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x43f0
jmp 0xf9d9
jmp 0xf9d4
jmp 0xf940
cmpl $0x3, -0x2c(%rbp)
jne 0xf9e6
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xf9f5
movq -0x18(%rbp), %rdi
callq 0x42b0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprLong
int
Hax_ExprLong(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    long *ptr				/* Where to store result. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    *ptr = value.llongValue;
	} else if (value.type == TYPE_DOUBLE) {
	    *ptr = value.doubleValue;
	} else {
	    interp->result = (char *) "expression didn't have numeric value";
	    result = HAX_ERROR;
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0xfaf0
movl %eax, -0x104(%rbp)
cmpl $0x0, -0x104(%rbp)
jne 0xfaab
cmpl $0x0, -0x30(%rbp)
jne 0xfa77
movq -0x100(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfaa9
cmpl $0x1, -0x30(%rbp)
jne 0xfa8f
cvttsd2si -0xf8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfaa7
movq -0x8(%rbp), %rax
leaq 0xefcc(%rip), %rcx      # 0x1ea66
movq %rcx, (%rax)
movl $0x1, -0x104(%rbp)
jmp 0xfaa9
jmp 0xfaab
movq -0xf0(%rbp), %rax
leaq -0x100(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
je 0xfade
movq -0x28(%rbp), %rdi
movq -0xf0(%rbp), %rsi
leaq 0xefb7(%rip), %rdx      # 0x1ea8b
movl $0x4cd, %ecx            # imm = 0x4CD
callq 0x4260
movl -0x104(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxExpr.c
// Function: ExprTopLevel
static int
ExprTopLevel(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    Value *valuePtr			/* Where to store result.  Should
					 * not be initialized by caller. */)
{
    ExprInfo info;
    int result;

    info.originalExpr = string;
    info.expr = string;
    valuePtr->pv.buffer = valuePtr->pv.next = valuePtr->staticSpace;
    valuePtr->pv.end = valuePtr->pv.buffer + STATIC_STRING_SPACE - 1;
    valuePtr->pv.expandProc = HaxExpandParseValue;
    valuePtr->pv.clientData = (ClientData) NULL;

    result = ExprGetValue(interp, &info, -1, valuePtr);
    if (result != HAX_OK) {
	return result;
    }
    if (info.token != END) {
	Hax_AppendResult(interp, "syntax error in expression \"",
		string, "\"", (char *) NULL);
	return HAX_ERROR;
    }
    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, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
addq $0x38, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x96, %rcx
addq $-0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x1348e(%rip), %rcx     # 0x22fe0
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xffe0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xfb89
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfbc1
cmpl $0x3, -0x28(%rbp)
je 0xfbba
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xeef7(%rip), %rsi      # 0x1ea95
leaq 0xd6cb(%rip), %rcx      # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xfbc1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprLongLong
int
Hax_ExprLongLong(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    long long int *ptr			/* Where to store result. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    *ptr = value.llongValue;
	} else if (value.type == TYPE_DOUBLE) {
	    *ptr = value.doubleValue;
	} else {
	    interp->result = (char *) "expression didn't have numeric value";
	    result = HAX_ERROR;
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0xfaf0
movl %eax, -0x104(%rbp)
cmpl $0x0, -0x104(%rbp)
jne 0xfc6b
cmpl $0x0, -0x30(%rbp)
jne 0xfc37
movq -0x100(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfc69
cmpl $0x1, -0x30(%rbp)
jne 0xfc4f
cvttsd2si -0xf8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfc67
movq -0x8(%rbp), %rax
leaq 0xee0c(%rip), %rcx      # 0x1ea66
movq %rcx, (%rax)
movl $0x1, -0x104(%rbp)
jmp 0xfc69
jmp 0xfc6b
movq -0xf0(%rbp), %rax
leaq -0x100(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
je 0xfc9e
movq -0x28(%rbp), %rdi
movq -0xf0(%rbp), %rsi
leaq 0xedf7(%rip), %rdx      # 0x1ea8b
movl $0x4ea, %ecx            # imm = 0x4EA
callq 0x4260
movl -0x104(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprBoolean
int
Hax_ExprBoolean(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    int *ptr				/* Where to store 0/1 result. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    *ptr = value.llongValue != 0;
	} else if (value.type == TYPE_DOUBLE) {
	    *ptr = value.doubleValue != 0.0;
	} else {
	    interp->result = (char *) "expression didn't have numeric value";
	    result = HAX_ERROR;
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0xfaf0
movl %eax, -0x104(%rbp)
cmpl $0x0, -0x104(%rbp)
jne 0xfe45
cmpl $0x0, -0x30(%rbp)
jne 0xfdff
cmpq $0x0, -0x100(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xfe43
cmpl $0x1, -0x30(%rbp)
jne 0xfe29
movsd -0xf8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xfe41
movq -0x8(%rbp), %rax
leaq 0xec32(%rip), %rcx      # 0x1ea66
movq %rcx, (%rax)
movl $0x1, -0x104(%rbp)
jmp 0xfe43
jmp 0xfe45
movq -0xf0(%rbp), %rax
leaq -0x100(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
je 0xfe78
movq -0x28(%rbp), %rdi
movq -0xf0(%rbp), %rsi
leaq 0xec1d(%rip), %rdx      # 0x1ea8b
movl $0x524, %ecx            # imm = 0x524
callq 0x4260
movl -0x104(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprString
int
Hax_ExprString(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string			/* Expression to evaluate. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    sprintf(interp->result, "%lld", value.llongValue);
	} else if (value.type == TYPE_DOUBLE) {
	    sprintf(interp->result, "%g", value.doubleValue);
	} else {
	    if (value.pv.buffer != value.staticSpace) {
		interp->result = value.pv.buffer;
		interp->freeProc = (Hax_FreeProc *) free;
		value.pv.buffer = value.staticSpace;
	    } else {
		Hax_SetResult(interp, value.pv.buffer, HAX_VOLATILE);
	    }
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0xfaf0
movl %eax, -0xfc(%rbp)
cmpl $0x0, -0xfc(%rbp)
jne 0xff92
cmpl $0x0, -0x28(%rbp)
jne 0xff08
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0xf8(%rbp), %rdx
leaq 0xddd2(%rip), %rsi      # 0x1dcce
movb $0x0, %al
callq 0x45d0
jmp 0xff90
cmpl $0x1, -0x28(%rbp)
jne 0xff2d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movsd -0xf0(%rbp), %xmm0
leaq 0xe563(%rip), %rsi      # 0x1e487
movb $0x1, %al
callq 0x45d0
jmp 0xff8e
movq -0xe8(%rbp), %rax
leaq -0xf8(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
je 0xff75
movq -0xe8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x1304b(%rip), %rcx     # 0x22fa8
movq %rcx, 0x8(%rax)
leaq -0xf8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0xe8(%rbp)
jmp 0xff8c
movq -0x8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq $-0x1, %rdx
callq 0x44e0
jmp 0xff8e
jmp 0xff90
jmp 0xff92
movq -0xe8(%rbp), %rax
leaq -0xf8(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
je 0xffc5
movq -0x20(%rbp), %rdi
movq -0xe8(%rbp), %rsi
leaq 0xead0(%rip), %rdx      # 0x1ea8b
movl $0x558, %ecx            # imm = 0x558
callq 0x4260
movl -0xfc(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxExpr.c
// Function: ExprMakeString
static void
ExprMakeString(
    Hax_Interp *interp,
    Value *valuePtr		/* Value to be converted. */)
{
    int shortfall;

    shortfall = 150 - (valuePtr->pv.end - valuePtr->pv.buffer);
    if (shortfall > 0) {
	(*valuePtr->pv.expandProc)(interp, &valuePtr->pv, shortfall);
    }
    if (valuePtr->type == TYPE_LLONG) {
	sprintf(valuePtr->pv.buffer, "%lld", valuePtr->llongValue);
    } else if (valuePtr->type == TYPE_DOUBLE) {
	sprintf(valuePtr->pv.buffer, "%g", valuePtr->doubleValue);
    }
    valuePtr->type = TYPE_STRING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
subq %rax, %rcx
movl $0x96, %eax
subq %rcx, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1183d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x10(%rbp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x11869
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xc46e(%rip), %rsi      # 0x1dcce
movb $0x0, %al
callq 0x45d0
jmp 0x11897
movq -0x10(%rbp), %rax
cmpl $0x1, 0xd0(%rax)
jne 0x11895
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0xcbf9(%rip), %rsi      # 0x1e487
movb $0x1, %al
callq 0x45d0
jmp 0x11897
movq -0x10(%rbp), %rax
movl $0x2, 0xd0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxGet.c
// Function: Hax_GetInt
int
Hax_GetInt(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a (possibly signed)
				 * integer in a form acceptable to strtol. */
    int *intPtr			/* Place to store converted result. */)
{
    char *end;
    int i;

    i = Strtol(NULL, string, &end, 0);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected integer but got \"", string,
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    *intPtr = i;
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x43b0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2d(%rbp)
je 0x11b4f
callq 0x4630
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x11b58
jmp 0x11b66
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11b1a
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x11b7c
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11ba7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xd094(%rip), %rsi      # 0x1ec1f
leaq 0xb6de(%rip), %rcx      # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x11bb7
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxGet.c
// Function: Hax_GetLong
int
Hax_GetLong(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a (possibly signed)
				 * integer in a form acceptable to strtol. */
    long int *longPtr		/* Place to store converted result. */)
{
    char *end;
    long int i;

    i = Strtol(NULL, string, &end, 0);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected integer but got \"", string,
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    *longPtr = i;
    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), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x43b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x11c20
callq 0x4630
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11c29
jmp 0x11c37
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11beb
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x11c4d
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11c78
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xcfc3(%rip), %rsi      # 0x1ec1f
leaq 0xb60d(%rip), %rcx      # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x11c8a
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
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/haxGet.c
// Function: Hax_GetLongLong
int
Hax_GetLongLong(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a (possibly signed)
				 * integer in a form acceptable to strtol. */
    long long int *llongPtr	/* Place to store converted result. */)
{
    char *end;
    long long int i;

    i = Strtoll(NULL, string, &end, 0);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected integer but got \"", string,
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    *llongPtr = i;
    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), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x41c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x11d00
callq 0x4630
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11d09
jmp 0x11d17
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11ccb
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x11d2d
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11d58
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xcee3(%rip), %rsi      # 0x1ec1f
leaq 0xb52d(%rip), %rcx      # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x11d6a
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
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/haxGet.c
// Function: Hax_GetDouble
int
Hax_GetDouble(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a floating-point number
				 * in a form acceptable to strtod. */
    void *doublePtr		/* Place to store converted result. */)
{
    char *end;
    double d;

    d = strtod(string, &end);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected floating-point number but got \"",
		string, "\"", (char *) NULL);
	return HAX_ERROR;
    }
    *(double *)doublePtr = d;
    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), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4130
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x11ddb
callq 0x4630
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11de4
jmp 0x11df2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11da6
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x11e08
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11e33
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xce23(%rip), %rsi      # 0x1ec3a
leaq 0xb452(%rip), %rcx      # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x11e47
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: Hax_InitHashTable
void
Hax_InitHashTable(
    Hax_HashTable *tablePtr,	/* Pointer to table record, which
					 * is supplied by the caller. */
    int keyType				/* Type of keys to use in table:
					 * HAX_STRING_KEYS, HAX_ONE_WORD_KEYS,
					 * or an integer >= 2. */)
{
    tablePtr->buckets = tablePtr->staticBuckets;
    tablePtr->staticBuckets[0] = tablePtr->staticBuckets[1] = 0;
    tablePtr->staticBuckets[2] = tablePtr->staticBuckets[3] = 0;
    tablePtr->numBuckets = HAX_SMALL_HASH_TABLE;
    tablePtr->numEntries = 0;
    tablePtr->rebuildSize = HAX_SMALL_HASH_TABLE*REBUILD_MULTIPLIER;
    tablePtr->downShift = 28;
    tablePtr->mask = 3;
    tablePtr->keyType = keyType;
    if (keyType == HAX_STRING_KEYS) {
	tablePtr->findProc = StringFind;
	tablePtr->createProc = StringCreate;
    } else if (keyType == HAX_ONE_WORD_KEYS) {
	tablePtr->findProc = OneWordFind;
	tablePtr->createProc = OneWordCreate;
    } else {
	tablePtr->findProc = ArrayFind;
	tablePtr->createProc = ArrayCreate;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0xc, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x1c, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x38(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x12131
movq -0x8(%rbp), %rax
leaq 0x64(%rip), %rcx        # 0x12180
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x115(%rip), %rcx       # 0x12240
movq %rcx, 0x48(%rax)
jmp 0x12177
cmpl $0x1, -0xc(%rbp)
jne 0x12157
movq -0x8(%rbp), %rax
leaq 0x2be(%rip), %rcx       # 0x12400
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x32f(%rip), %rcx       # 0x12480
movq %rcx, 0x48(%rax)
jmp 0x12175
movq -0x8(%rbp), %rax
leaq 0x48e(%rip), %rcx       # 0x125f0
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x59f(%rip), %rcx       # 0x12710
movq %rcx, 0x48(%rax)
jmp 0x12177
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: StringFind
static Hax_HashEntry *
StringFind(
    Hax_HashTable *tablePtr,	/* Table in which to lookup entry. */
    char *key			/* Key to use to find matching entry. */)
{
    Hax_HashEntry *hPtr;
    char *p1, *p2;
    int index;

    index = HashString(key) & tablePtr->mask;

    /*
     * Search all of the entries in the appropriate bucket.
     */

    for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
	    hPtr = hPtr->nextPtr) {
	for (p1 = key, p2 = hPtr->key.string; ; p1++, p2++) {
	    if (*p1 != *p2) {
		break;
	    }
	    if (*p1 == '\0') {
		return hPtr;
	    }
	}
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12eb0
movq -0x10(%rbp), %rcx
andl 0x38(%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12226
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x121e5
jmp 0x12217
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x121fb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1222e
jmp 0x121fd
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x121d1
jmp 0x12219
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x121b6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: OneWordFind
static Hax_HashEntry *
OneWordFind(
    Hax_HashTable *tablePtr,	/* Table in which to lookup entry. */
    char *key			/* Key to use to find matching entry. */)
{
    Hax_HashEntry *hPtr;
    int index;

    index = RANDOM_INDEX(tablePtr, key);

    /*
     * Search all of the entries in the appropriate bucket.
     */

    for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
	    hPtr = hPtr->nextPtr) {
	if (hPtr->key.oneWordValue == key) {
	    return hPtr;
	}
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
imulq $0x41c64e6d, %rax, %rax # imm = 0x41C64E6D
movq -0x10(%rbp), %rcx
movl 0x34(%rcx), %ecx
sarq %cl, %rax
movq -0x10(%rbp), %rcx
movslq 0x38(%rcx), %rcx
andq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12470
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x12461
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12478
jmp 0x12463
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12442
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: ArrayFind
static Hax_HashEntry *
ArrayFind(
    Hax_HashTable *tablePtr,	/* Table in which to lookup entry. */
    char *key			/* Key to use to find matching entry. */)
{
    Hax_HashEntry *hPtr;
    int *arrayPtr = (int *) key;
    int *iPtr1, *iPtr2;
    int index, count;

    for (index = 0, count = tablePtr->keyType, iPtr1 = arrayPtr;
	    count > 0; count--, iPtr1++) {
	index += *iPtr1;
    }
    index = RANDOM_INDEX(tablePtr, index);

    /*
     * Search all of the entries in the appropriate bucket.
     */

    for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
	    hPtr = hPtr->nextPtr) {
	for (iPtr1 = arrayPtr, iPtr2 = hPtr->key.words,
		count = tablePtr->keyType; ; count--, iPtr1++, iPtr2++) {
	    if (count == 0) {
		return hPtr;
	    }
	    if (*iPtr1 != *iPtr2) {
		break;
	    }
	}
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x40(%rbp)
jle 0x12646
movq -0x30(%rbp), %rax
movl (%rax), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x1261d
movslq -0x3c(%rbp), %rax
imulq $0x41c64e6d, %rax, %rax # imm = 0x41C64E6D
movq -0x10(%rbp), %rcx
movl 0x34(%rcx), %ecx
sarq %cl, %rax
movq -0x10(%rbp), %rcx
movslq 0x38(%rcx), %rcx
andq %rcx, %rax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x126f5
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jne 0x126b1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x126fd
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
je 0x126c1
jmp 0x126e6
jmp 0x126c3
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x126a1
jmp 0x126e8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1267c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: Hax_DeleteHashEntry
void
Hax_DeleteHashEntry(
    Hax_Interp *interp,
    Hax_HashEntry *entryPtr)
{
    Interp *iPtr = (Interp *)interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Hax_HashEntry *prevPtr;

    if (*entryPtr->bucketPtr == entryPtr) {
	*entryPtr->bucketPtr = entryPtr->nextPtr;
    } else {
	for (prevPtr = *entryPtr->bucketPtr; ; prevPtr = prevPtr->nextPtr) {
	    if (prevPtr == NULL) {
		Hax_Panic(
		    (char *) "malformed bucket chain in Hax_DeleteHashEntry");
	    }
	    if (prevPtr->nextPtr == entryPtr) {
		prevPtr->nextPtr = entryPtr->nextPtr;
		break;
	    }
	}
    }
    entryPtr->tablePtr->numEntries--;
    ckfree(memoryp, (char *) entryPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x129bc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
jmp 0x12a0e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x129e0
leaq 0xc2d7(%rip), %rdi      # 0x1ecb0
movb $0x0, %al
callq 0x4120
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x129fd
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12a0c
jmp 0x129ff
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x129cb
jmp 0x12a0e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xa9f1(%rip), %rdx      # 0x1d41f
movl $0xa0, %ecx
callq 0x4260
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: Hax_DeleteHashTable
void
Hax_DeleteHashTable(
    Hax_Interp *interp,
    Hax_HashTable *tablePtr		/* Table to delete. */)
{
    Interp *iPtr = (Interp *)interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Hax_HashEntry *hPtr, *nextPtr;
    int i;

    /*
     * Free up all the entries in the table.
     */

    for (i = 0; i < tablePtr->numBuckets; i++) {
	hPtr = tablePtr->buckets[i];
	while (hPtr != NULL) {
	    nextPtr = hPtr->nextPtr;
	    ckfree(memoryp, (char *) hPtr);
	    hPtr = nextPtr;
	}
    }

    /*
     * Free up the bucket array, if it was dynamically allocated.
     */

    if (tablePtr->buckets != tablePtr->staticBuckets) {
	ckfree(memoryp, (char *) tablePtr->buckets);
    }

    /*
     * Arrange for panics if the table is used again without
     * re-initialization.
     */

    tablePtr->findProc = BogusFind;
    tablePtr->createProc = BogusCreate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x12acf
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12ac2
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0xa971(%rip), %rdx      # 0x1d41f
movl $0xc6, %ecx
callq 0x4260
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x12a8d
jmp 0x12ac4
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12a6e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x12aff
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa92a(%rip), %rdx      # 0x1d41f
movl $0xd0, %ecx
callq 0x4260
movq -0x10(%rbp), %rax
leaq 0x26(%rip), %rcx        # 0x12b30
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
leaq 0x47(%rip), %rcx        # 0x12b60
movq %rcx, 0x48(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: Hax_FirstHashEntry
Hax_HashEntry *
Hax_FirstHashEntry(
    Hax_HashTable *tablePtr,		/* Table to search. */
    Hax_HashSearch *searchPtr		/* Place to store information about
					 * progress through the table. */)
{
    searchPtr->tablePtr = tablePtr;
    searchPtr->nextIndex = 0;
    searchPtr->nextEntryPtr = NULL;
    return Hax_NextHashEntry(searchPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x4370
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHash.c
// Function: Hax_NextHashEntry
Hax_HashEntry *
Hax_NextHashEntry(
    Hax_HashSearch *searchPtr	/* Place to store information about
					 * progress through the table.  Must
					 * have been initialized by calling
					 * Hax_FirstHashEntry. */)
{
    Hax_HashEntry *hPtr;

    while (searchPtr->nextEntryPtr == NULL) {
	if (searchPtr->nextIndex >= searchPtr->tablePtr->numBuckets) {
	    return NULL;
	}
	searchPtr->nextEntryPtr =
		searchPtr->tablePtr->buckets[searchPtr->nextIndex];
	searchPtr->nextIndex++;
    }
    hPtr = searchPtr->nextEntryPtr;
    searchPtr->nextEntryPtr = hPtr->nextPtr;
    return hPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x12c3d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x28(%rcx), %eax
jl 0x12c10
movq $0x0, -0x8(%rbp)
jmp 0x12c60
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x12be8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
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/haxHistory.c
// Function: Hax_InitHistory
void
Hax_InitHistory(
    Hax_Interp *interp		/* Interpreter to initialize. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int i;

    if (iPtr->numEvents != 0) {
	return;
    }
    iPtr->numEvents = 20;
    iPtr->events = (HistoryEvent *)
	    ckalloc(memoryp,
		(unsigned) (iPtr->numEvents * sizeof(HistoryEvent)));
    for (i = 0; i < iPtr->numEvents; i++) {
	iPtr->events[i].command = (char *) ckalloc(memoryp, INITIAL_CMD_SIZE);
	*iPtr->events[i].command = 0;
	iPtr->events[i].bytesAvl = INITIAL_CMD_SIZE;
    }
    iPtr->curEvent = 0;
    iPtr->curEventNum = 0;
    Hax_CreateCommand((Hax_Interp *) iPtr, (char *) "history", Hax_HistoryCmd,
	    (ClientData) NULL, (Hax_CmdDeleteProc *) NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xd8(%rax)
je 0x131b5
jmp 0x132c7
movq -0x10(%rbp), %rax
movl $0x14, 0xd8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0xd8(%rax), %rax
shlq $0x4, %rax
movl %eax, %eax
movl %eax, %esi
leaq 0xbbf7(%rip), %rdx      # 0x1edd8
movl $0x86, %ecx
callq 0x44c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe0(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xd8(%rcx), %eax
jge 0x1328c
movq -0x18(%rbp), %rdi
movl $0x28, %esi
leaq 0xbbb9(%rip), %rdx      # 0x1edd8
movl $0x88, %ecx
callq 0x44c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x28, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13200
movq -0x10(%rbp), %rax
movl $0x0, 0xe8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xec(%rax)
movq -0x10(%rbp), %rdi
leaq 0xbb32(%rip), %rsi      # 0x1ede5
movq 0xfd06(%rip), %rdx      # 0x22fc0
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x4030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHistory.c
// Function: MakeSpace
static void
MakeSpace(
    Interp *iPtr,
    HistoryEvent *hPtr,
    int size			/* # of bytes needed in hPtr. */)
{
    Hax_Memoryp *memoryp = iPtr->memoryp;
    if (hPtr->bytesAvl < size) {
	ckfree(memoryp, hPtr->command);
	hPtr->command = (char *) ckalloc(memoryp, (unsigned) size);
	hPtr->bytesAvl = size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x14538
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa8d8(%rip), %rdx      # 0x1edd8
movl $0x21c, %ecx            # imm = 0x21C
callq 0x4260
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0xa8be(%rip), %rdx      # 0x1edd8
movl $0x21d, %ecx            # imm = 0x21D
callq 0x44c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxHistory.c
// Function: RevCommand
static void
RevCommand(
    Interp *iPtr,		/* Interpreter in which to perform the
				 * substitution. */
    char *string		/* String to substitute. */)
{
    Hax_Memoryp *memoryp = iPtr->memoryp;
    HistoryRev *revPtr;

    if ((iPtr->evalFirst == NULL) || (iPtr->revDisables > 0)) {
	return;
    }
    revPtr = (HistoryRev *) ckalloc(memoryp, sizeof(HistoryRev));
    revPtr->firstIndex = iPtr->evalFirst - iPtr->historyFirst;
    revPtr->lastIndex = iPtr->evalLast - iPtr->historyFirst;
    revPtr->newSize = strlen(string);
    revPtr->newBytes =
	(char *) ckalloc(memoryp, (unsigned) (revPtr->newSize+1));
    strcpy(revPtr->newBytes, string);
    InsertRev(iPtr, revPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x1492a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x100(%rax)
jle 0x1492f
jmp 0x149ee
movq -0x18(%rbp), %rdi
movl $0x20, %esi
leaq 0xa499(%rip), %rdx      # 0x1edd8
movl $0x286, %ecx            # imm = 0x286
callq 0x44c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x41b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0xa41d(%rip), %rdx      # 0x1edd8
movl $0x28b, %ecx            # imm = 0x28B
callq 0x44c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14f90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxParse.c
// Function: HaxExpandParseValue
void
HaxExpandParseValue(
    Hax_Interp *interp,
    ParseValue *pvPtr,			/* Information about buffer that
					 * must be expanded.  If the clientData
					 * in the structure is non-zero, it
					 * means that the current buffer is
					 * dynamically allocated. */
    int needed				/* Minimum amount of additional space
					 * to allocate. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int newSpace;
    char *newBuf;

    /*
     * Either double the size of the buffer or add enough new space
     * to meet the demand, whichever produces a larger new buffer.
     */

    newSpace = (pvPtr->end - pvPtr->buffer) + 1;
    if (newSpace < needed) {
	newSpace += needed;
    } else {
	newSpace += newSpace;
    }
    newBuf = (char *) ckalloc(memoryp, (unsigned) newSpace);

    /*
     * Copy from old buffer to new, free old buffer if needed, and
     * mark newBuf buffer as malloc-ed.
     */

    memcpy(newBuf, pvPtr->buffer, pvPtr->next - pvPtr->buffer);
    pvPtr->next = newBuf + (pvPtr->next - pvPtr->buffer);
    if (pvPtr->clientData != 0) {
	ckfree(memoryp, pvPtr->buffer);
    }
    pvPtr->buffer = newBuf;
    pvPtr->end = newBuf + newSpace - 1;
    pvPtr->clientData = (ClientData) 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x16386
movl -0x14(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1638f
movl -0x2c(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq 0x8e5c(%rip), %rdx      # 0x1f1fb
movl $0x34b, %ecx            # imm = 0x34B
callq 0x44c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
callq 0x4390
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x16417
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x8dee(%rip), %rdx      # 0x1f1fb
movl $0x355, %ecx            # imm = 0x355
callq 0x4260
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movslq -0x2c(%rbp), %rax
addq %rax, %rcx
addq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1, %ecx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)