// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::do_arithm_eval(char*, int, int, int*)
int do_arithm_eval(char *buf, int pos1, int pos2, int *result) {
        int spl1, spl2, result1, result2, l;
        char c, *p;

        while ((pos1 < pos2) && is_white(buf[pos1]))
            pos1++;
        while ((pos1 < pos2) && is_white(buf[pos2 - 1]))
            pos2--;
        if (pos1 == pos2)
            return 0;

        // look for C operators starting with lowest precedence

        if (splice_infix(buf, pos1, pos2, "||", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 || result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "&&", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 && result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "|", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 | result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "^", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 ^ result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "&", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 & result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "!=", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2)) {
                // revert to string comparison
                while ((pos1 < spl1) && is_white(buf[spl1 - 1]))
                    spl1--;
                while ((pos2 > spl2) && is_white(buf[spl2]))
                    spl2++;
                if (spl1 - pos1 != pos2 - spl2)
                    *result = 1;
                else
                    *result = (strncmp(buf + pos1, buf + spl2, spl1 - pos1) != 0);
            } else
                *result = (result1 != result2);
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "==", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2)) {
                // revert to string comparison
                while ((pos1 < spl1) && is_white(buf[spl1 - 1]))
                    spl1--;
                while ((pos2 > spl2) && is_white(buf[spl2]))
                    spl2++;
                if (spl1 - pos1 != pos2 - spl2)
                    *result = 0;
                else
                    *result = (strncmp(buf + pos1, buf + spl2, spl1 - pos1) == 0);
            } else
                *result = (result1 == result2);
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "=~", &spl1, &spl2)) {
            bug("globbing not allowed");
        }

        if (splice_infix(buf, pos1, pos2, ">=", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2)) {
                // revert to string comparison
                while ((pos1 < spl1) && is_white(buf[spl1 - 1]))
                    spl1--;
                while ((pos2 > spl2) && is_white(buf[spl2]))
                    spl2++;
                l = spl1 - pos1;
                if (l > pos2 - spl2)
                    l = pos2 - spl2;
                result1 = strncmp(buf + pos1, buf + spl2, l);
                *result = (result1 > 0)
                        || ((result1 == 0) && (spl1 - pos1 >= pos2 - spl2));
            } else
                *result = (result1 >= result2);
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, ">", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2)) {
                // revert to string comparison
                while ((pos1 < spl1) && is_white(buf[spl1 - 1]))
                    spl1--;
                while ((pos2 > spl2) && is_white(buf[spl2]))
                    spl2++;
                l = spl1 - pos1;
                if (l > pos2 - spl2)
                    l = pos2 - spl2;
                result1 = strncmp(buf + pos1, buf + spl2, l);
                *result = (result1 > 0)
                        || ((result1 == 0) && (spl1 - pos1 > pos2 - spl2));
            } else
                *result = (result1 > result2);
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "<=", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2)) {
                // revert to string comparison
                while ((pos1 < spl1) && is_white(buf[spl1 - 1]))
                    spl1--;
                while ((pos2 > spl2) && is_white(buf[spl2]))
                    spl2++;
                l = spl1 - pos1;
                if (l > pos2 - spl2)
                    l = pos2 - spl2;
                result1 = strncmp(buf + pos1, buf + spl2, l);
                *result = (result1 < 0)
                        || ((result1 == 0) && (spl1 - pos1 <= pos2 - spl2));
            } else
                *result = (result1 <= result2);
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "<", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2)) {
                // revert to string comparison
                while ((pos1 < spl1) && is_white(buf[spl1 - 1]))
                    spl1--;
                while ((pos2 > spl2) && is_white(buf[spl2]))
                    spl2++;
                l = spl1 - pos1;
                if (l > pos2 - spl2)
                    l = pos2 - spl2;
                result1 = strncmp(buf + pos1, buf + spl2, l);
                *result = (result1 < 0)
                        || ((result1 == 0) && (spl1 - pos1 < pos2 - spl2));
            } else
                *result = (result1 < result2);
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "+", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 + result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "-", &spl1, &spl2))
            if (spl1 != pos1) {
                if (!do_arithm_eval(buf, pos1, spl1, &result1)
                        || !do_arithm_eval(buf, spl2, pos2, &result2))
                    return 0;
                *result = result1 - result2;
                return 1;
            }

        if (splice_infix(buf, pos1, pos2, "*", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            *result = result1 * result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "/", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            if (result2 == 0)
                bug("division by zero in expression");
            *result = result1 / result2;
            return 1;
        }

        if (splice_infix(buf, pos1, pos2, "%", &spl1, &spl2)) {
            if (!do_arithm_eval(buf, pos1, spl1, &result1)
                    || !do_arithm_eval(buf, spl2, pos2, &result2))
                return 0;
            if (result2 == 0)
                bug("division by zero in expression");
            *result = result1 % result2;
            return 1;
        }

        if (buf[pos1] == '~') {
            if (!do_arithm_eval(buf, pos1 + 1, pos2, &result1))
                return 0;
            *result = ~result1;
            return 1;
        }

        if (buf[pos1] == '!') {
            if (!do_arithm_eval(buf, pos1 + 1, pos2, &result1))
                return 0;
            *result = !result1;
            return 1;
        }

        if (buf[pos1] == '-') {
            if (!do_arithm_eval(buf, pos1 + 1, pos2, &result1))
                return 0;
            *result = -result1;
            return 1;
        }

        // add the length() builtin to measure the length of the macro expansion
        if (strncmp(buf + pos1, "length(", strlen("length(")) == 0) {
            if (buf[pos2 - 1] != ')')
                return 0;
            *result = pos2 - pos1 - strlen("length()");
            return 1;
        }

        if (buf[pos1] == '(') {
            if (buf[pos2 - 1] != ')')
                return 0;
            return do_arithm_eval(buf, pos1 + 1, pos2 - 1, result);
        }

        c = buf[pos2];
        buf[pos2] = 0;
        *result = (int) strtol(buf + pos1, &p, 0);
        buf[pos2] = c;
        return (p == buf + pos2);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r15
cmpl %edx, %esi
jge 0x704e
movslq %ebp, %rax
addq %r15, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x704e
btq %rdx, %rcx
jae 0x704e
incl %ebp
incq %rax
cmpl %ebp, %r14d
jne 0x7033
jmp 0x707d
cmpl %r14d, %ebp
jge 0x7085
movslq %r14d, %r14
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r14), %edx
cmpq $0x20, %rdx
ja 0x7085
btq %rdx, %rcx
jae 0x7085
decq %r14
cmpq %rax, %r14
jg 0x7063
xorl %r12d, %r12d
jmp 0x729a
xorl %r12d, %r12d
movl %r14d, %r13d
subl %ebp, %r13d
je 0x729a
leaq 0x1af6(%rip), %rcx      # 0x8b91
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7101
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
orl 0x10(%rsp), %eax
setne %cl
movl %ecx, (%rbx)
jmp 0x7294
leaq 0x1a8c(%rip), %rcx      # 0x8b94
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7174
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
cmpl $0x0, 0x10(%rsp)
setne %al
cmpl $0x0, 0xc(%rsp)
setne %cl
andb %al, %cl
movzbl %cl, %eax
jmp 0x7292
leaq 0x136c(%rip), %rcx      # 0x84e7
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x71da
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %eax
orl 0x10(%rsp), %eax
jmp 0x7292
leaq 0x19b6(%rip), %rcx      # 0x8b97
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7239
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %eax
xorl 0x10(%rsp), %eax
jmp 0x7292
leaq 0x1955(%rip), %rcx      # 0x8b95
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x72ac
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %eax
andl 0x10(%rsp), %eax
movl %eax, (%rbx)
movl $0x1, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18e6(%rip), %rcx      # 0x8b99
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x73a7
movl 0x8(%rsp), %r12d
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7006
testl %eax, %eax
je 0x7314
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x7314
movl 0x10(%rsp), %eax
xorl %ecx, %ecx
cmpl 0xc(%rsp), %eax
jmp 0x70f7
cmpl %r12d, %ebp
jge 0x7346
movslq %r12d, %r12
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r12), %edx
cmpq $0x20, %rdx
ja 0x7346
btq %rdx, %rcx
jae 0x7346
decq %r12
cmpq %rax, %r12
jg 0x7329
movl %ebp, %r12d
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jle 0x737b
movslq %eax, %rcx
addq %r15, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x737b
btq %rsi, %rdx
jae 0x737b
incl %eax
incq %rcx
cmpl %eax, %r14d
jne 0x735f
movl %r14d, %eax
subl %ebp, %r12d
subl %eax, %r14d
cmpl %r14d, %r12d
jne 0x740f
movslq %ebp, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
movslq %r12d, %rdx
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
jmp 0x70f7
leaq 0x17ee(%rip), %rcx      # 0x8b9c
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x74b0
movl 0x8(%rsp), %r12d
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7006
testl %eax, %eax
je 0x741a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x741a
movl 0x10(%rsp), %eax
xorl %ecx, %ecx
cmpl 0xc(%rsp), %eax
jmp 0x74a8
movl $0x1, (%rbx)
jmp 0x7294
cmpl %r12d, %ebp
jge 0x744c
movslq %r12d, %r12
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r12), %edx
cmpq $0x20, %rdx
ja 0x744c
btq %rdx, %rcx
jae 0x744c
decq %r12
cmpq %rax, %r12
jg 0x742f
movl %ebp, %r12d
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jle 0x7481
movslq %eax, %rcx
addq %r15, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x7481
btq %rsi, %rdx
jae 0x7481
incl %eax
incq %rcx
cmpl %eax, %r14d
jne 0x7465
movl %r14d, %eax
subl %ebp, %r12d
subl %eax, %r14d
cmpl %r14d, %r12d
jne 0x753f
movslq %ebp, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
movslq %r12d, %rdx
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x70fa
leaq 0x16e8(%rip), %rcx      # 0x8b9f
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
jne 0x7c76
leaq 0x16da(%rip), %rcx      # 0x8bb7
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x75ed
movl 0x8(%rsp), %r12d
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7006
testl %eax, %eax
je 0x754a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x754a
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
setge %cl
jmp 0x716c
movl $0x0, (%rbx)
jmp 0x7294
cmpl %r12d, %ebp
jge 0x757c
movslq %r12d, %r12
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r12), %edx
cmpq $0x20, %rdx
ja 0x757c
btq %rdx, %rcx
jae 0x757c
decq %r12
cmpq %rax, %r12
jg 0x755f
movl %ebp, %r12d
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jle 0x75b1
movslq %eax, %rcx
addq %r15, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x75b1
btq %rsi, %rdx
jae 0x75b1
incl %eax
incq %rcx
cmpl %eax, %r14d
jne 0x7595
movl %r14d, %eax
subl %ebp, %r12d
subl %eax, %r14d
cmpl %r14d, %r12d
movl %r14d, %ecx
cmovll %r12d, %ecx
movslq %ebp, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
movslq %ecx, %rdx
callq 0x2080
movb $0x1, %cl
testl %eax, %eax
jg 0x716c
sete %al
cmpl %r14d, %r12d
setge %cl
jmp 0x716a
leaq 0x15c6(%rip), %rcx      # 0x8bba
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x76fd
movl 0x8(%rsp), %r12d
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7006
testl %eax, %eax
je 0x7656
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x7656
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
setg %cl
jmp 0x716c
cmpl %r12d, %ebp
jge 0x7688
movslq %r12d, %r12
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r12), %edx
cmpq $0x20, %rdx
ja 0x7688
btq %rdx, %rcx
jae 0x7688
decq %r12
cmpq %rax, %r12
jg 0x766b
movl %ebp, %r12d
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jle 0x76bd
movslq %eax, %rcx
addq %r15, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x76bd
btq %rsi, %rdx
jae 0x76bd
incl %eax
incq %rcx
cmpl %eax, %r14d
jne 0x76a1
movl %r14d, %eax
subl %ebp, %r12d
subl %eax, %r14d
cmpl %r14d, %r12d
movl %r14d, %ecx
cmovll %r12d, %ecx
movslq %ebp, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
movslq %ecx, %rdx
callq 0x2080
movb $0x1, %cl
testl %eax, %eax
jg 0x716c
cmpl %r14d, %r12d
setg %dl
testl %eax, %eax
sete %cl
andb %dl, %cl
jmp 0x716c
leaq 0x14b8(%rip), %rcx      # 0x8bbc
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7809
movl 0x8(%rsp), %r12d
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7006
testl %eax, %eax
je 0x7766
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x7766
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
setle %cl
jmp 0x716c
cmpl %r12d, %ebp
jge 0x7798
movslq %r12d, %r12
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r12), %edx
cmpq $0x20, %rdx
ja 0x7798
btq %rdx, %rcx
jae 0x7798
decq %r12
cmpq %rax, %r12
jg 0x777b
movl %ebp, %r12d
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jle 0x77cd
movslq %eax, %rcx
addq %r15, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x77cd
btq %rsi, %rdx
jae 0x77cd
incl %eax
incq %rcx
cmpl %eax, %r14d
jne 0x77b1
movl %r14d, %eax
subl %ebp, %r12d
subl %eax, %r14d
cmpl %r14d, %r12d
movl %r14d, %ecx
cmovll %r12d, %ecx
movslq %ebp, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
movslq %ecx, %rdx
callq 0x2080
movb $0x1, %cl
testl %eax, %eax
js 0x716c
sete %al
cmpl %r14d, %r12d
setle %cl
jmp 0x716a
leaq 0x13af(%rip), %rcx      # 0x8bbf
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7915
movl 0x8(%rsp), %r12d
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7006
testl %eax, %eax
je 0x7872
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x7872
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
setl %cl
jmp 0x716c
cmpl %r12d, %ebp
jge 0x78a4
movslq %r12d, %r12
movslq %ebp, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%r15,%r12), %edx
cmpq $0x20, %rdx
ja 0x78a4
btq %rdx, %rcx
jae 0x78a4
decq %r12
cmpq %rax, %r12
jg 0x7887
movl %ebp, %r12d
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jle 0x78d9
movslq %eax, %rcx
addq %r15, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x78d9
btq %rsi, %rdx
jae 0x78d9
incl %eax
incq %rcx
cmpl %eax, %r14d
jne 0x78bd
movl %r14d, %eax
subl %ebp, %r12d
subl %eax, %r14d
cmpl %r14d, %r12d
movl %r14d, %ecx
cmovll %r12d, %ecx
movslq %ebp, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
movslq %ecx, %rdx
callq 0x2080
movb $0x1, %cl
testl %eax, %eax
js 0x716c
sete %al
cmpl %r14d, %r12d
setl %cl
jmp 0x716a
leaq 0x12a5(%rip), %rcx      # 0x8bc1
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x797b
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %eax
addl 0x10(%rsp), %eax
jmp 0x7292
leaq 0x1241(%rip), %rcx      # 0x8bc3
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x79a5
movl 0x8(%rsp), %edx
cmpl %ebp, %edx
jne 0x7a10
leaq 0xb4d(%rip), %rcx       # 0x84f9
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7a50
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %eax
imull 0x10(%rsp), %eax
jmp 0x7292
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x10(%rsp), %eax
subl 0xc(%rsp), %eax
jmp 0x7292
leaq 0xaa5(%rip), %rcx       # 0x84fc
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7ac1
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
je 0x7c82
movl 0x10(%rsp), %eax
cltd
idivl %ecx
jmp 0x7292
leaq 0x111c(%rip), %rcx      # 0x8be4
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7c8e
testl %eax, %eax
je 0x7b34
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
je 0x7c82
movl 0x10(%rsp), %eax
cltd
idivl %ecx
movl %edx, (%rbx)
jmp 0x7294
movslq %ebp, %rax
movq %rax, %rdi
movzbl (%r15,%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x21, %eax
je 0x7b7d
cmpl $0x2d, 0x1c(%rsp)
je 0x7ba8
cmpl $0x7e, 0x1c(%rsp)
jne 0x7bcf
incl %ebp
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
movl 0x10(%rsp), %eax
notl %eax
jmp 0x7292
incl %ebp
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
sete %al
jmp 0x7292
incl %ebp
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7006
testl %eax, %eax
je 0x729a
xorl %eax, %eax
subl 0x10(%rsp), %eax
jmp 0x7292
addq %r15, %rdi
leaq 0x100d(%rip), %rsi      # 0x8be6
movl $0x7, %edx
movq %rdi, 0x20(%rsp)
callq 0x2080
testl %eax, %eax
je 0x7c22
cmpb $0x28, 0x1c(%rsp)
jne 0x7c3d
movslq %r14d, %rdx
cmpb $0x29, -0x1(%r15,%rdx)
jne 0x729a
decq %rdx
incl %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7006
movslq %r14d, %rax
cmpb $0x29, -0x1(%r15,%rax)
jne 0x729a
addl $-0x8, %r13d
movl %r13d, (%rbx)
jmp 0x7294
movslq %r14d, %r12
leaq (%r15,%r12), %r13
movb (%r15,%r12), %bpl
movb $0x0, (%r15,%r12)
leaq 0x10(%rsp), %r14
movq 0x20(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21d0
movl %eax, (%rbx)
movb %bpl, (%r15,%r12)
xorl %r12d, %r12d
cmpq %r13, (%r14)
sete %r12b
jmp 0x729a
leaq 0xf25(%rip), %rdi       # 0x8ba2
callq 0x2fa0
leaq 0xf3c(%rip), %rdi       # 0x8bc5
callq 0x2fa0