// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdMZ.c
// Function: TraceVarProc
static char *
TraceVarProc(
    ClientData clientData,	/* Information about the variable trace. */
    Hax_Interp *interp,		/* Interpreter containing variable. */
    char *name1,		/* Name of variable or array. */
    char *name2,		/* Name of element within array;  NULL means
				 * scalar variable is being referenced. */
    int flags			/* OR-ed bits giving operation and other
				 * information. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData;
    char *result;
    int code, cmdLength, flags1, flags2;
    Interp dummy;
#define STATIC_SIZE 199
    char staticSpace[STATIC_SIZE+1];
    char *cmdPtr, *p;

    result = NULL;
    if ((tvarPtr->flags & flags) && !(flags & HAX_INTERP_DESTROYED)) {

	/*
	 * Generate a command to execute by appending list elements
	 * for the two variable names and the operation.  The five
	 * extra characters are for three space, the opcode character,
	 * and the terminating null.
	 */

	if (name2 == NULL) {
	    name2 = (char *) "";
	}
	cmdLength = tvarPtr->length + Hax_ScanElement(name1, &flags1) +
		Hax_ScanElement(name2, &flags2) + 5;
	if (cmdLength < STATIC_SIZE) {
	    cmdPtr = staticSpace;
	} else {
	    cmdPtr = (char *) ckalloc(memoryp, (unsigned) cmdLength);
	}
	p = cmdPtr;
	strcpy(p, tvarPtr->command);
	p += tvarPtr->length;
	*p = ' ';
	p++;
	p += Hax_ConvertElement(name1, p, flags1);
	*p = ' ';
	p++;
	p += Hax_ConvertElement(name2, p, flags2);
	*p = ' ';
	if (flags & HAX_TRACE_READS) {
	    p[1] = 'r';
	} else if (flags & HAX_TRACE_WRITES) {
	    p[1] = 'w';
	} else if (flags & HAX_TRACE_UNSETS) {
	    p[1] = 'u';
	}
	p[2] = '\0';

	/*
	 * Execute the command.  Be careful to save and restore the
	 * result from the interpreter used for the command.
	 */

	dummy.memoryp = iPtr->memoryp;
	if (interp->freeProc == 0) {
	    dummy.freeProc = (Hax_FreeProc *) 0;
	    dummy.result = dummy.resultSpace;
	    dummy.resultSpace[0] = 0;
	    Hax_SetResult((Hax_Interp *) &dummy, interp->result, HAX_VOLATILE);
	} else {
	    dummy.freeProc = interp->freeProc;
	    dummy.result = interp->result;
	}
	code = Hax_Eval(interp, NULL, cmdPtr, 0, (char **) NULL);
	if (cmdPtr != staticSpace) {
	    ckfree(memoryp, cmdPtr);
	}
	if (code != HAX_OK) {
	    result = (char *) "access disallowed by trace command";
	    Hax_ResetResult(interp);		/* Must clear error state. */
	}
	Hax_FreeResult(interp);
	if (dummy.result == dummy.resultSpace) {
	    if (dummy.freeProc != HAX_STATIC) {
		Hax_Panic((char *) "Corrupted state of dummy Interpreter");
	    }
	    iPtr->result = iPtr->resultSpace;
	    strcpy(iPtr->resultSpace, dummy.resultSpace);
	    iPtr->freeProc = HAX_STATIC;
	} else {
	    interp->result = dummy.result;
	    interp->freeProc = dummy.freeProc;
	}
    }
    if (flags & HAX_TRACE_DESTROYED) {
	ckfree(memoryp, (char *) tvarPtr);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
andl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0xf8b6
movl -0x24(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0xf8b6
cmpq $0x0, -0x20(%rbp)
jne 0xf53b
leaq 0xf93c(%rip), %rax      # 0x1ee73
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x418(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x4100
movl %eax, %ecx
movl -0x418(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x414(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4100
movl %eax, %ecx
movl -0x414(%rbp), %eax
addl %ecx, %eax
addl $0x5, %eax
movl %eax, -0x50(%rbp)
cmpl $0xc7, -0x50(%rbp)
jge 0xf59b
leaq -0x400(%rbp), %rax
movq %rax, -0x408(%rbp)
jmp 0xf5bc
movq -0x38(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
leaq 0xecd7(%rip), %rdx      # 0x1e282
movl $0x533, %ecx            # imm = 0x533
callq 0x44c0
movq %rax, -0x408(%rbp)
movq -0x408(%rbp), %rax
movq %rax, -0x410(%rbp)
movq -0x410(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
callq 0x40d0
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x410(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x410(%rbp)
movq -0x410(%rbp), %rax
movb $0x20, (%rax)
movq -0x410(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x410(%rbp)
movq -0x18(%rbp), %rdi
movq -0x410(%rbp), %rsi
movl -0x54(%rbp), %edx
callq 0x4150
movl %eax, %ecx
movq -0x410(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x410(%rbp)
movq -0x410(%rbp), %rax
movb $0x20, (%rax)
movq -0x410(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x410(%rbp)
movq -0x20(%rbp), %rdi
movq -0x410(%rbp), %rsi
movl -0x58(%rbp), %edx
callq 0x4150
movl %eax, %ecx
movq -0x410(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x410(%rbp)
movq -0x410(%rbp), %rax
movb $0x20, (%rax)
movl -0x24(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xf6a5
movq -0x410(%rbp), %rax
movb $0x72, 0x1(%rax)
jmp 0xf6d7
movl -0x24(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xf6bd
movq -0x410(%rbp), %rax
movb $0x77, 0x1(%rax)
jmp 0xf6d5
movl -0x24(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xf6d3
movq -0x410(%rbp), %rax
movb $0x75, 0x1(%rax)
jmp 0xf6d5
jmp 0xf6d7
movq -0x410(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xf741
movq $0x0, -0x328(%rbp)
leaq -0x330(%rbp), %rax
addq $0x1b0, %rax            # imm = 0x1B0
movq %rax, -0x330(%rbp)
movb $0x0, -0x180(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x330(%rbp), %rdi
movq $-0x1, %rdx
callq 0x44e0
jmp 0xf75e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x328(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x330(%rbp)
movq -0x10(%rbp), %rdi
movq -0x408(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rsi
callq 0x45b0
movl %eax, -0x4c(%rbp)
movq -0x408(%rbp), %rax
leaq -0x400(%rbp), %rcx
cmpq %rcx, %rax
je 0xf7aa
movq -0x38(%rbp), %rdi
movq -0x408(%rbp), %rsi
leaq 0xeae2(%rip), %rdx      # 0x1e282
movl $0x559, %ecx            # imm = 0x559
callq 0x4260
cmpl $0x0, -0x4c(%rbp)
je 0xf7c4
leaq 0xef8c(%rip), %rax      # 0x1e743
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42b0
jmp 0xf7c6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf825
movq -0x10(%rbp), %rax
movq 0x137cc(%rip), %rcx     # 0x22fa8
cmpq %rcx, 0x8(%rax)
jne 0xf808
movq -0x10(%rbp), %rdi
callq 0x4540
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xea86(%rip), %rdx      # 0x1e282
movl $0x55f, %ecx            # imm = 0x55F
callq 0x4260
jmp 0xf819
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xf827
movq -0x330(%rbp), %rax
leaq -0x330(%rbp), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
cmpq %rcx, %rax
jne 0xf897
cmpq $0x0, -0x328(%rbp)
je 0xf859
leaq 0xef14(%rip), %rdi      # 0x1e766
movb $0x0, %al
callq 0x4120
movq -0x30(%rbp), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
leaq -0x330(%rbp), %rsi
addq $0x1b0, %rsi            # imm = 0x1B0
callq 0x40d0
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xf8b4
movq -0x330(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x328(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xf8b6
movl -0x24(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xf8dc
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0xe9b0(%rip), %rdx      # 0x1e282
movl $0x56d, %ecx            # imm = 0x56D
callq 0x4260
movq -0x48(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)