// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_FormatCmd
int
Hax_FormatCmd(
    ClientData dummy,			/* 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;
    char *format;	/* Used to read characters from the format
				 * string. */
    char newFormat[40];		/* A new format specifier is generated here. */
    int width;			/* Field width from field specifier, or 0 if
				 * no width given. */
    int precision;		/* Field precision from field specifier, or 0
				 * if no precision given. */
    int size;			/* Number of bytes needed for result of
				 * conversion, based on type of conversion
				 * ("e", "s", etc.) and width from above. */
    char *oneWordValue = NULL;	/* Used to hold value to pass to sprintf, if
				 * it's a one-word value. */
    double twoWordValue;	/* Used to hold value to pass to sprintf if
				 * it's a two-word value. */
    int useTwoWords;		/* 0 means use oneWordValue, 1 means use
				 * twoWordValue. */
    char *dst = interp->result;	/* Where result is stored.  Starts off at
				 * interp->resultSpace, but may get dynamically
				 * re-allocated if this isn't enough. */
    int dstSize = 0;		/* Number of non-null characters currently
				 * stored at dst. */
    int dstSpace = HAX_RESULT_SIZE;
				/* Total amount of storage space available
				 * in dst (not including null terminator. */
    int noPercent;		/* Special case for speed:  indicates there's
				 * no field specifier, just a string to copy. */
    char **curArg;		/* Remainder of argv array. */
    int useShort;		/* Value to be printed is short (half word). */

    /*
     * This procedure is a bit nasty.  The goal is to use sprintf to
     * do most of the dirty work.  There are several problems:
     * 1. this procedure can't trust its arguments.
     * 2. we must be able to provide a large enough result area to hold
     *    whatever's generated.  This is hard to estimate.
     * 2. there's no way to move the arguments from argv to the call
     *    to sprintf in a reasonable way.  This is particularly nasty
     *    because some of the arguments may be two-word values (doubles).
     * So, what happens here is to scan the format string one % group
     * at a time, making many individual calls to sprintf.
     */

    if (argc < 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" formatString ?arg arg ...?\"", (char *) NULL);
	return HAX_ERROR;
    }
    curArg = argv+2;
    argc -= 2;
    for (format = argv[1]; *format != 0; ) {
	char *newPtr = newFormat;

	width = precision = useTwoWords = noPercent = useShort = 0;

	/*
	 * Get rid of any characters before the next field specifier.
	 * Collapse backslash sequences found along the way.
	 */

	if (*format != '%') {
	    char *p;
	    int bsSize;

	    oneWordValue = p = format;
	    while ((*format != '%') && (*format != 0)) {
		if (*format == '\\') {
		    *p = Hax_Backslash(format, &bsSize);
		    if (*p != 0) {
			p++;
		    }
		    format += bsSize;
		} else {
		    *p = *format;
		    p++;
		    format++;
		}
	    }
	    size = p - oneWordValue;
	    noPercent = 1;
	    goto doField;
	}

	if (format[1] == '%') {
	    oneWordValue = format;
	    size = 1;
	    noPercent = 1;
	    format += 2;
	    goto doField;
	}

	/*
	 * Parse off a field specifier, compute how many characters
	 * will be needed to store the result, and substitute for
	 * "*" size specifiers.
	 */

	*newPtr = '%';
	newPtr++;
	format++;
	while ((*format == '-') || (*format == '#') || (*format == '0')
		|| (*format == ' ') || (*format == '+')) {
	    *newPtr = *format;
	    newPtr++;
	    format++;
	}
	if (isdigit(*format)) {
	    width = atoi(format);
	    do {
		format++;
	    } while (isdigit(*format));
	} else if (*format == '*') {
	    if (argc <= 0) {
		goto notEnoughArgs;
	    }
	    if (Hax_GetInt(interp, *curArg, &width) != HAX_OK) {
		goto fmtError;
	    }
	    argc--;
	    curArg++;
	    format++;
	}
	if (width != 0) {
	    sprintf(newPtr, "%d", width);
	    while (*newPtr != 0) {
		newPtr++;
	    }
	}
	if (*format == '.') {
	    *newPtr = '.';
	    newPtr++;
	    format++;
	}
	if (isdigit(*format)) {
	    precision = atoi(format);
	    do {
		format++;
	    } while (isdigit(*format));
	} else if (*format == '*') {
	    if (argc <= 0) {
		goto notEnoughArgs;
	    }
	    if (Hax_GetInt(interp, *curArg, &precision) != HAX_OK) {
		goto fmtError;
	    }
	    argc--;
	    curArg++;
	    format++;
	}
	if (precision != 0) {
	    sprintf(newPtr, "%d", precision);
	    while (*newPtr != 0) {
		newPtr++;
	    }
	}
	if (*format == 'l') {
	    format++;
	} else if (*format == 'h') {
	    useShort = 1;
	    *newPtr = 'h';
	    newPtr++;
	    format++;
	}
	*newPtr = *format;
	newPtr++;
	*newPtr = 0;
	if (argc <= 0) {
	    goto notEnoughArgs;
	}
	switch (*format) {
	    case 'D':
	    case 'O':
	    case 'U':
		if (!useShort) {
		    newPtr++;
		} else {
		    useShort = 0;
		}
		newPtr[-1] = tolower(*format);
		newPtr[-2] = 'l';
		*newPtr = 0;
	    case 'd':
	    case 'o':
	    case 'u':
	    case 'x':
	    case 'X':
		if (Hax_GetLong(interp, *curArg, (long *) &oneWordValue)
			!= HAX_OK) {
		    goto fmtError;
		}
		size = 40;
		break;
	    case 's':
		oneWordValue = *curArg;
		size = strlen(*curArg);
		break;
	    case 'c':
		if (Hax_GetLong(interp, *curArg, (long *) &oneWordValue)
			!= HAX_OK) {
		    goto fmtError;
		}
		size = 1;
		break;
	    case 'F':
		newPtr[-1] = tolower(newPtr[-1]);
	    case 'e':
	    case 'E':
	    case 'f':
	    case 'g':
	    case 'G':
		if (Hax_GetDouble(interp, *curArg, &twoWordValue) != HAX_OK) {
		    goto fmtError;
		}
		useTwoWords = 1;
		size = 320;
		if (precision > 10) {
		    size += precision;
		}
		break;
	    case 0:
		interp->result =
			(char *) "format string ended in middle of field "
			    "specifier";
		goto fmtError;
	    default:
		sprintf(interp->result, "bad field specifier \"%c\"", *format);
		goto fmtError;
	}
	argc--;
	curArg++;
	format++;

	/*
	 * Make sure that there's enough space to hold the formatted
	 * result, then format it.
	 */

	doField:
	if (width > size) {
	    size = width;
	}
	if ((dstSize + size) > dstSpace) {
	    char *newDst;
	    int newSpace;

	    newSpace = 2*(dstSize + size);
	    newDst = (char *) ckalloc(memoryp, (unsigned) newSpace+1);
	    if (dstSize != 0) {
		memcpy(newDst, dst, dstSize);
	    }
	    if (dstSpace != HAX_RESULT_SIZE) {
		ckfree(memoryp, dst);
	    }
	    dst = newDst;
	    dstSpace = newSpace;
	}
	if (noPercent) {
	    memcpy((dst+dstSize), oneWordValue, size);
	    dstSize += size;
	    dst[dstSize] = 0;
	} else {
	    if (useTwoWords) {
		sprintf(dst+dstSize, newFormat, twoWordValue);
	    } else if (useShort) {
		/*
		 * The double cast below is needed for a few machines
		 * (e.g. Pyramids as of 1/93) that don't like casts
		 * directly from pointers to shorts.
		 */

		sprintf(dst+dstSize, newFormat, (short) (long) oneWordValue);
	    } else {
		sprintf(dst+dstSize, newFormat, (char *) oneWordValue);
	    }
	    dstSize += strlen(dst+dstSize);
	}
    }

    interp->result = dst;
    if (dstSpace != HAX_RESULT_SIZE) {
	interp->freeProc = (Hax_FreeProc *) free;
    } else {
	interp->freeProc = 0;
    }
    return HAX_OK;

    notEnoughArgs:
    interp->result = (char *) "not enough arguments for all format specifiers";
    fmtError:
    if (dstSpace != HAX_RESULT_SIZE) {
	ckfree(memoryp, dst);
    }
    return HAX_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %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)
movq $0x0, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
movl $0xc7, -0xa8(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x9c95
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x13cfe(%rip), %rsi     # 0x1d974
leaq 0x13ed3(%rip), %rcx     # 0x1db50
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xa5d9
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xb8(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa55c
leaq -0x70(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xbc(%rbp)
movl $0x0, -0xac(%rbp)
movl $0x0, -0x94(%rbp)
movl $0x0, -0x78(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x9e0b
movq -0x40(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq %rax, -0x88(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x25, %ecx
movb %al, -0xe5(%rbp)
je 0x9d49
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xe5(%rbp)
movb -0xe5(%rbp), %al
testb $0x1, %al
jne 0x9d58
jmp 0x9de8
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x9db6
movq -0x40(%rbp), %rdi
leaq -0xd4(%rbp), %rsi
callq 0x42a0
movb %al, %cl
movq -0xd0(%rbp), %rax
movb %cl, (%rax)
movq -0xd0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9da0
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
movl -0xd4(%rbp), %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x9de3
movq -0x40(%rbp), %rax
movb (%rax), %cl
movq -0xd0(%rbp), %rax
movb %cl, (%rax)
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x9d22
movq -0xd0(%rbp), %rax
movq -0x88(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x7c(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0xa397
movq -0x40(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x25, %eax
jne 0x9e45
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x1, -0x7c(%rbp)
movl $0x1, -0xac(%rbp)
movq -0x40(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0xa397
movq -0xc8(%rbp), %rax
movb $0x25, (%rax)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0xe6(%rbp)
je 0x9ed0
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x23, %ecx
movb %al, -0xe6(%rbp)
je 0x9ed0
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0xe6(%rbp)
je 0x9ed0
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xe6(%rbp)
je 0x9ed0
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
sete %al
movb %al, -0xe6(%rbp)
movb -0xe6(%rbp), %al
testb $0x1, %al
jne 0x9edc
jmp 0x9f0e
movq -0x40(%rbp), %rax
movb (%rax), %cl
movq -0xc8(%rbp), %rax
movb %cl, (%rax)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x9e6d
callq 0x4630
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x9f68
movq -0x40(%rbp), %rdi
callq 0x4580
movl %eax, -0x74(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
callq 0x4630
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x9f3a
jmp 0x9fc9
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x9fc7
cmpl $0x0, -0x1c(%rbp)
jg 0x9f7f
jmp 0xa59c
movq -0x18(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq (%rax), %rsi
leaq -0x74(%rbp), %rdx
callq 0x41a0
cmpl $0x0, %eax
je 0x9fa0
jmp 0xa5aa
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0xb8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x9fc9
cmpl $0x0, -0x74(%rbp)
je 0xa00c
movq -0xc8(%rbp), %rdi
movl -0x74(%rbp), %edx
leaq 0x132f4(%rip), %rsi     # 0x1d2d4
movb $0x0, %al
callq 0x45d0
movq -0xc8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa00a
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0x9fe7
jmp 0xa00c
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xa040
movq -0xc8(%rbp), %rax
movb $0x2e, (%rax)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
callq 0x4630
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xa09a
movq -0x40(%rbp), %rdi
callq 0x4580
movl %eax, -0x78(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
callq 0x4630
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xa06c
jmp 0xa0fb
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0xa0f9
cmpl $0x0, -0x1c(%rbp)
jg 0xa0b1
jmp 0xa59c
movq -0x18(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq (%rax), %rsi
leaq -0x78(%rbp), %rdx
callq 0x41a0
cmpl $0x0, %eax
je 0xa0d2
jmp 0xa5aa
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0xb8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xa0fb
cmpl $0x0, -0x78(%rbp)
je 0xa13e
movq -0xc8(%rbp), %rdi
movl -0x78(%rbp), %edx
leaq 0x131c2(%rip), %rsi     # 0x1d2d4
movb $0x0, %al
callq 0x45d0
movq -0xc8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa13c
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xa119
jmp 0xa13e
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0xa158
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xa198
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
jne 0xa196
movl $0x1, -0xbc(%rbp)
movq -0xc8(%rbp), %rax
movb $0x68, (%rax)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xa198
movq -0x40(%rbp), %rax
movb (%rax), %cl
movq -0xc8(%rbp), %rax
movb %cl, (%rax)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x1c(%rbp)
jg 0xa1ce
jmp 0xa59c
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
movl %eax, %ecx
movq %rcx, -0xf0(%rbp)
subl $0x78, %eax
ja 0xa34f
movq -0xf0(%rbp), %rax
leaq 0x1359b(%rip), %rcx     # 0x1d790
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, -0xbc(%rbp)
jne 0xa21b
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xa225
movl $0x0, -0xbc(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %edi
callq 0x4400
movb %al, %cl
movq -0xc8(%rbp), %rax
movb %cl, -0x1(%rax)
movq -0xc8(%rbp), %rax
movb $0x6c, -0x2(%rax)
movq -0xc8(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdx
callq 0x44b0
cmpl $0x0, %eax
je 0xa276
jmp 0xa5aa
movl $0x28, -0x7c(%rbp)
jmp 0xa370
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0xb8(%rbp), %rax
movq (%rax), %rdi
callq 0x41b0
movl %eax, -0x7c(%rbp)
jmp 0xa370
movq -0x18(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdx
callq 0x44b0
cmpl $0x0, %eax
je 0xa2ce
jmp 0xa5aa
movl $0x1, -0x7c(%rbp)
jmp 0xa370
movq -0xc8(%rbp), %rax
movsbl -0x1(%rax), %edi
callq 0x4400
movb %al, %cl
movq -0xc8(%rbp), %rax
movb %cl, -0x1(%rax)
movq -0x18(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq (%rax), %rsi
leaq -0x90(%rbp), %rdx
callq 0x45a0
cmpl $0x0, %eax
je 0xa31a
jmp 0xa5aa
movl $0x1, -0x94(%rbp)
movl $0x140, -0x7c(%rbp)     # imm = 0x140
cmpl $0xa, -0x78(%rbp)
jle 0xa33a
movl -0x78(%rbp), %eax
addl -0x7c(%rbp), %eax
movl %eax, -0x7c(%rbp)
jmp 0xa370
movq -0x18(%rbp), %rax
leaq 0x13826(%rip), %rcx     # 0x1db6d
movq %rcx, (%rax)
jmp 0xa5aa
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movsbl (%rax), %edx
leaq 0x1383a(%rip), %rsi     # 0x1db9e
movb $0x0, %al
callq 0x45d0
jmp 0xa5aa
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0xb8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x74(%rbp), %eax
cmpl -0x7c(%rbp), %eax
jle 0xa3a5
movl -0x74(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0xa4(%rbp), %eax
addl -0x7c(%rbp), %eax
cmpl -0xa8(%rbp), %eax
jle 0xa459
movl -0xa4(%rbp), %eax
addl -0x7c(%rbp), %eax
shll %eax
movl %eax, -0xe4(%rbp)
movq -0x38(%rbp), %rdi
movl -0xe4(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x13601(%rip), %rdx     # 0x1d9e4
movl $0x370, %ecx            # imm = 0x370
callq 0x44c0
movq %rax, -0xe0(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0xa417
movq -0xe0(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movslq -0xa4(%rbp), %rdx
callq 0x4390
cmpl $0xc7, -0xa8(%rbp)
je 0xa43f
movq -0x38(%rbp), %rdi
movq -0xa0(%rbp), %rsi
leaq 0x135af(%rip), %rdx     # 0x1d9e4
movl $0x375, %ecx            # imm = 0x375
callq 0x4260
movq -0xe0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0xe4(%rbp), %eax
movl %eax, -0xa8(%rbp)
cmpl $0x0, -0xac(%rbp)
je 0xa4a9
movq -0xa0(%rbp), %rdi
movslq -0xa4(%rbp), %rax
addq %rax, %rdi
movq -0x88(%rbp), %rsi
movslq -0x7c(%rbp), %rdx
callq 0x4390
movl -0x7c(%rbp), %eax
addl -0xa4(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0xa0(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xa557
cmpl $0x0, -0x94(%rbp)
je 0xa4d8
movq -0xa0(%rbp), %rdi
movslq -0xa4(%rbp), %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movsd -0x90(%rbp), %xmm0
movb $0x1, %al
callq 0x45d0
jmp 0xa52e
cmpl $0x0, -0xbc(%rbp)
je 0xa509
movq -0xa0(%rbp), %rdi
movslq -0xa4(%rbp), %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rax
movswl %ax, %edx
movb $0x0, %al
callq 0x45d0
jmp 0xa52c
movq -0xa0(%rbp), %rdi
movslq -0xa4(%rbp), %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rdx
movb $0x0, %al
callq 0x45d0
jmp 0xa52e
movq -0xa0(%rbp), %rdi
movslq -0xa4(%rbp), %rax
addq %rax, %rdi
callq 0x41b0
movq %rax, %rcx
movslq -0xa4(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xa4(%rbp)
jmp 0x9cb9
movq -0xa0(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0xc7, -0xa8(%rbp)
je 0xa587
movq -0x18(%rbp), %rax
movq 0x18a27(%rip), %rcx     # 0x22fa8
movq %rcx, 0x8(%rax)
jmp 0xa593
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa5d9
movq -0x18(%rbp), %rax
leaq 0x13610(%rip), %rcx     # 0x1dbb7
movq %rcx, (%rax)
cmpl $0xc7, -0xa8(%rbp)
je 0xa5d2
movq -0x38(%rbp), %rdi
movq -0xa0(%rbp), %rsi
leaq 0x1341c(%rip), %rdx     # 0x1d9e4
movl $0x39c, %ecx            # imm = 0x39C
callq 0x4260
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop