// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: optimize_expression
static opt_t optimize_expression(s7_scheme *sc, s7_pointer expr, int32_t hop, s7_pointer e, bool export_ok)
                {
                    s7_pointer car_expr;
#if OPTIMIZE_PRINT
                    fprintf(stderr, "optimize_expression %s %d %s\n", DISPLAY(expr), hop, DISPLAY(e));
#endif
                    set_checked(expr);
                    car_expr = car(expr);

                    if (is_symbol(car_expr))
                    {
                        s7_pointer slot;
                        if (is_syntactic_symbol(car_expr))
                        {
                            if (!is_pair(cdr(expr)))
                                return(OPT_OOPS);
                            return(optimize_syntax(sc, expr, T_Syn(slot_value(global_slot(car_expr))), hop, e, export_ok));
                        }

                        slot = find_uncomplicated_symbol(sc, car_expr, e); /* local vars (recursive calls too??) are considered "complicated" */
#if OPTIMIZE_PRINT
                        if (!is_slot(slot)) fprintf(stderr, "  %s is not simple\n", DISPLAY(expr));
#endif
                        if (is_slot(slot))
                        {
                            s7_pointer func;
                            func = slot_value(slot);
                            if (is_syntax(func))                           /* 12-8-16 was is_syntactic, but that is only appropriate above -- here we have the value */
                            {
                                if (!is_pair(cdr(expr)))
                                    return(OPT_OOPS);
                                return(optimize_syntax(sc, expr, func, hop, e, export_ok));  /* e can be extended via set-cdr! here */
                            }
                            if (is_any_macro(func)) return(OPT_F);

                            /* we miss implicit indexing here because at this time, the data are not set */
                            if ((is_t_procedure(func)) ||
                                    /* (is_c_function(func)) || */
                                    (is_safe_procedure(func)))                 /* built-in applicable objects like vectors */
                            {
                                int32_t pairs = 0, symbols = 0, args = 0, bad_pairs = 0, quotes = 0, orig_hop;
                                s7_pointer p;
                                orig_hop = hop;

                                if ((hop != 0) &&
                                        ((is_any_closure(func)) ||             /* see use-redef in s7test -- I'm not sure about this */
                                         ((!is_global(car_expr)) &&
                                          ((!is_slot(global_slot(car_expr))) ||
                                           (slot_value(global_slot(car_expr)) != func)))) &&
                                        (!is_immutable(car_expr)) && /* list|apply-values -- can't depend on opt1 here because it might not be global, or might be redefined locally */
                                        (!is_immutable(slot)))       /* (define-constant...) */
                                {
                                    /* (let () (define (f2 a) (+ a 1)) (define (f1 a) (f2 a)) (define (f2 a) (- a)) (f1 12))
                                     * (let () (define (f2 a) (+ a 1)) (define (f1 a) (f2 a)) (define (f2 a) (- a 1)) (f1 12))
                                     * and similar define* cases
                                     */
                                    hop = 0;
                                    /* this is very tricky!  See s7test for some cases.  Basically, we need to protect a recursive call
                                     *   of the current function being optimized from being confused with some previous definition
                                     *   of the same name.  But method lists have global names so the global bit is off even though the
                                     *   thing is actually a safe global.  But no closure can be considered safe in the hop sense --
                                     *   even a global function might be redefined at any time, and previous uses of it in other functions
                                     *   need to reflect its new value.
                                     *   So, closures are always checked, but built-in functions are used as if never redefined until that redefinition.
                                     * Syntax handling is already impure in s7, so the special handling of built-in functions doesn't
                                     *   offend me much.  Consider each a sort of reader macro until someone redefines it -- previous
                                     *   uses may not be affected because they might have been optimized away -- the result depends on the
                                     *   current optimizer.
                                     * Another case (from K Matheussen):
                                     *   (define (call-func func arg1 arg2) (define (call) (func arg1 arg2)) (call)) (call-func + 1 2.5) (call-func - 5 2)
                                     *   when we get here originally "func" is +, hop=1, but just checking for !is_global(car_expr) is
                                     *   not good enough -- if we load mockery.scm, nothing is global!
                                     * Yet another case (define (test-abs) (define (abs x) (+ x 1)) (format *stderr* "abs ~A~%" (abs -1)))
                                     *   when optimize_syntax sees the (define abs ...), it inserts abs into e so that the caller's e is extended (set-cdr!)
                                     *   so that find_uncomplicated_symbol above will be unhappy when we reach (abs -1) as the format arg.
                                     *   This can be confused if lambda is redefined at some point, but...
                                     */
                                }

                                for (p = cdr(expr); is_pair(p); p = cdr(p), args++) /* check the args (the calling expression) */
                                {
                                    s7_pointer car_p;
                                    car_p = car(p);
                                    if (is_normal_symbol(car_p)) /* for opt func */
                                        symbols++;
                                    else
                                    {
                                        if (is_pair(car_p))
                                        {
                                            pairs++;
                                            if (!is_checked(car_p))
                                            {
                                                opt_t res;
                                                res = optimize_expression(sc, car_p, orig_hop, e, false);
                                                if (res == OPT_F)
                                                {
                                                    bad_pairs++;
                                                    if (is_proper_quote(sc, car_p))
                                                        quotes++;
                                                }
                                                else
                                                {
                                                    if (res == OPT_OOPS)
                                                        return(OPT_OOPS);
                                                }
                                            }
                                            else
                                            {
                                                if ((!is_optimized(car_p)) ||
                                                        (is_unsafe(car_p)))
                                                {
                                                    bad_pairs++;
                                                    if (is_proper_quote(sc, car_p))
                                                        quotes++;
                                                }}}}}
                                if (is_null(p))                    /* if not null, dotted list of args? */
                                {
                                    switch (args)
                                    {
                                        case 0:  return(optimize_thunk(sc, expr, func, hop, e));
                                        case 1:  return(optimize_func_one_arg(sc, expr, func, hop, pairs, symbols, quotes, bad_pairs, e));
                                        case 2:  return(optimize_func_two_args(sc, expr, func, hop, pairs, symbols, quotes, bad_pairs, e));
                                        case 3:  return(optimize_func_three_args(sc, expr, func, hop, pairs, symbols, quotes, bad_pairs, e));
                                        default: return(optimize_func_many_args(sc, expr, func, hop, args, pairs, symbols, quotes, bad_pairs, e));
                                    }
                                }
                                return(OPT_F);
                            }
                        }
                        else
                        {
                            if ((sc->undefined_identifier_warnings) &&
                                    (slot == sc->undefined) &&           /* car_expr is not in e or global */
                                    (symbol_tag(car_expr) == 0))         /*    and we haven't looked it up earlier */
                            {
                                s7_pointer p;
                                p = sc->input_port;
                                if ((is_input_port(p)) &&
                                        (port_file(p) != stdin) &&
                                        (!port_is_closed(p)) &&
                                        (port_filename(p)))
                                    s7_warn(sc, 1024, "%s might be undefined (%s %u)\n", DISPLAY(car_expr), port_filename(p), port_line_number(p));
                                else s7_warn(sc, 1024, "; %s might be undefined\n", DISPLAY(car_expr));
                                symbol_set_tag(car_expr, 1);             /* one warning is enough */
                            }
                        }
#if OPTIMIZE_PRINT
                        fprintf(stderr, "  at line %d for %s\n", __LINE__, DISPLAY(car_expr));
#endif
                        /* car_expr is a symbol but it's not a built-in procedure or a "safe" case = vector etc */
                        {
                            /* else maybe it's something like a let variable binding: (sqrtfreq (sqrt frequency)) */
                            s7_pointer p;
                            int32_t len = 0, pairs = 0, symbols = 0;

                            for (p = cdr(expr); is_pair(p); p = cdr(p), len++)
                            {
                                s7_pointer car_p;
                                car_p = car(p);
                                if (is_pair(car_p))
                                {
                                    pairs++;
                                    if ((!is_checked(car_p)) &&
                                            (optimize_expression(sc, car_p, hop, e, false) == OPT_OOPS))
                                        return(OPT_OOPS);
                                }
                                else
                                {
                                    if (is_symbol(car_p))
                                        symbols++;
                                }
                            }

                            if ((is_null(p)) &&              /* (+ 1 . 2) */
                                    (!is_optimized(expr)))
                            {
                                /* len=0 case is almost entirely arglists */
                                set_opt1_con(expr, sc->unused);

                                if (pairs == 0)
                                {
                                    if (len == 0)
                                    {
                                        /* hoping to catch object application here, as in readers in Snd */
                                        set_unsafe_optimize_op(expr, OP_UNKNOWN);
                                        return(OPT_F);
                                    }

                                    if (len == 1)
                                    {
                                        if (car_expr != sc->quote_symbol) /* !! quote can be redefined locally, unsetting the T_SYNTACTIC flag -- can this happen elsewhere? */
                                            set_unsafe_optimize_op(expr, OP_UNKNOWN_G);
                                        return(OPT_F);
                                    }

                                    if (len == 2)
                                    {
                                        set_unsafely_optimized(expr);
                                        set_optimize_op(expr, OP_UNKNOWN_GG);
                                        return(OPT_F);
                                    }

                                    if ((len >= 3) &&
                                            (len == symbols))
                                    {
                                        set_unsafe_optimize_op(expr, OP_UNKNOWN_ALL_S);
                                        set_opt3_arglen(expr, make_permanent_integer(len));
                                        return(OPT_F);
                                    }
                                }
                                else /* pairs != 0 */
                                {
                                    s7_pointer arg1;
                                    arg1 = cadr(expr);
                                    if (pairs == 1)
                                    {
                                        if (len == 1)
                                        {

                                            if ((car(expr) == sc->quote_symbol) &&
                                                    (direct_memq(sc->quote_symbol, e)))
                                                return(OPT_OOPS);

                                            if (is_fxable(sc, arg1))
                                            {
                                                set_opt3_arglen(expr, small_int(1));
                                                annotate_arg(sc, cdr(expr), e);
                                                set_unsafe_optimize_op(expr, OP_UNKNOWN_A);
                                                return(OPT_F);
                                            }
                                        }
                                        else
                                        {
                                            if (len == 2)
                                            {
                                                if ((is_fxable(sc, arg1)) &&
                                                        (is_fxable(sc, caddr(expr))))
                                                {
                                                    set_opt3_arglen(expr, small_int(2));
                                                    set_unsafe_optimize_op(expr, OP_UNKNOWN_AA);
                                                    return(OPT_F);
                                                }}}}

                                    if ((len == 2) &&
                                            (is_fxable(sc, arg1)) &&
                                            (is_fxable(sc, caddr(expr))))
                                    {
                                        set_opt3_arglen(expr, small_int(2));
                                        set_unsafe_optimize_op(expr, OP_UNKNOWN_AA);
                                        return(OPT_F);
                                    }

                                    if ((fx_count(sc, expr) == len) &&
                                            (len < GC_TRIGGER_SIZE))
                                    {
                                        if ((len == 1) &&
                                                (car(expr) == sc->quote_symbol) &&
                                                (direct_memq(sc->quote_symbol, e)))
                                            return(OPT_OOPS);

                                        set_unsafe_optimize_op(expr, (len == 1) ? OP_UNKNOWN_A : OP_UNKNOWN_FX);
                                        set_opt3_arglen(expr, make_permanent_integer(len));
                                        if (len == 1)
                                            annotate_arg(sc, cdr(expr), e);
                                        return(OPT_F);
                                    }}}}
                    }
                    else
                    {
                        /* car(expr) is not a symbol, but there might be interesting stuff here */
                        /* (define (hi a) (case 1 ((1) (if (> a 2) a 2)))) */
                        s7_pointer p;

                        for (p = expr; is_pair(p); p = cdr(p))
                        {
                            if ((is_pair(car(p))) &&
                                    (!is_checked(car(p))) &&
                                    (optimize_expression(sc, car(p), hop, e, false) == OPT_OOPS))
                                return(OPT_OOPS);
                        }

                        if ((is_proper_list_1(sc, cdr(expr))) &&
                                (is_pair(car_expr)) &&
                                (car(car_expr) == sc->if_symbol) &&
                                (is_pair(cdr(car_expr))) &&
                                (is_pair(cddr(car_expr))) &&
                                (is_symbol(caddr(car_expr))) &&
                                (is_pair(cdddr(car_expr))) &&
                                (is_symbol(cadddr(car_expr))) &&
                                (is_fxable(sc, cadr(car_expr))) &&
                                (is_fxable(sc, cadr(expr))))
                        {
                            s7_pointer ptrue;
                            ptrue = find_uncomplicated_symbol(sc, caddr(car_expr), e);
                            if (is_slot(ptrue))
                            {
                                ptrue = slot_value(ptrue);
                                if ((is_c_function(ptrue)) &&
                                        (is_safe_procedure(ptrue)))
                                {
                                    s7_pointer pfalse;
                                    pfalse = find_uncomplicated_symbol(sc, cadddr(car_expr), e);
                                    if (is_slot(pfalse))
                                    {
                                        pfalse = slot_value(pfalse);
                                        if ((is_c_function(pfalse)) &&
                                                (is_safe_procedure(pfalse)))
                                        {
                                            set_opt1_con(expr, ptrue);
                                            set_opt2_con(expr, pfalse);
                                            set_safe_optimize_op(expr, OP_opIF_A_SSq_A);
                                            annotate_arg(sc, cdr(car_expr), e);
                                            annotate_arg(sc, cdr(expr), e);
                                            return(OPT_T);
                                        }}}}}
                    }
                    return(OPT_F);
                }

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movb %r8b, %al
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movl %edx, 0xe4(%rsp)
movq %rcx, 0xd8(%rsp)
andb $0x1, %al
movb %al, 0xd7(%rsp)
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x400000, %rcx         # imm = 0x400000
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x175d45
movq 0xc8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x20a, %eax            # imm = 0x20A
jne 0x174ee3
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x174e96
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
movl 0xe4(%rsp), %ecx
movq 0xd8(%rsp), %r8
movb 0xd7(%rsp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x1760c0
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x178880
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x175512
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x174fa9
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x174f64
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl 0xe4(%rsp), %ecx
movq 0xd8(%rsp), %r8
movb 0xd7(%rsp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x1760c0
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xa6ee3(%rip), %rax     # 0x21bea0
testb $0x1, (%rax,%rcx)
je 0x174fd3
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xa6e79(%rip), %rax     # 0x21be60
testb $0x1, (%rax,%rcx)
jne 0x175008
movq 0xb8(%rsp), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
je 0x17550d
movl $0x0, 0xb4(%rsp)
movl $0x0, 0xb0(%rsp)
movl $0x0, 0xac(%rsp)
movl $0x0, 0xa8(%rsp)
movl $0x0, 0xa4(%rsp)
movl 0xe4(%rsp), %eax
movl %eax, 0xa0(%rsp)
cmpl $0x0, 0xe4(%rsp)
je 0x1750f3
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xad6c1(%rip), %rax     # 0x222730
testb $0x1, (%rax,%rcx)
jne 0x1750ba
movq 0xc8(%rsp), %rax
movq (%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
jne 0x1750f3
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1750ba
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpq 0xb8(%rsp), %rax
je 0x1750f3
movq 0xc8(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
jne 0x1750f3
movq 0xc0(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
jne 0x1750f3
movl $0x0, 0xe4(%rsp)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1752da
movq 0x98(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x17516b
movq 0x90(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x17516b
movl 0xb0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb0(%rsp)
jmp 0x1752ae
movq 0x90(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1752ac
movl 0xb4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb4(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rax
andq $0x400000, %rax         # imm = 0x400000
cmpq $0x0, %rax
jne 0x175240
movq 0xf0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movl 0xa0(%rsp), %edx
movq 0xd8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x174df0
movl %eax, 0x8c(%rsp)
cmpl $0x0, 0x8c(%rsp)
jne 0x175222
movl 0xa8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf6a10
testb $0x1, %al
jne 0x17520f
jmp 0x175220
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0x17523e
cmpl $0x2, 0x8c(%rsp)
jne 0x17523c
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x17523e
jmp 0x1752aa
movq 0x90(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x801, %eax            # imm = 0x801
jne 0x175269
movq 0x90(%rsp), %rax
movq (%rax), %rax
andq $0x800000, %rax         # imm = 0x800000
cmpq $0x0, %rax
je 0x1752a8
movl 0xa8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf6a10
testb $0x1, %al
jne 0x175295
jmp 0x1752a6
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0x1752a8
jmp 0x1752aa
jmp 0x1752ac
jmp 0x1752ae
jmp 0x1752b0
movq 0x98(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x98(%rsp)
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x175107
movq 0x98(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x1754fd
movl 0xac(%rsp), %eax
movq %rax, 0x38(%rsp)
subq $0x3, %rax
ja 0x17548c
movq 0x38(%rsp), %rax
leaq 0x6b507(%rip), %rcx     # 0x1e0820
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl 0xe4(%rsp), %ecx
movq 0xd8(%rsp), %r8
callq 0x178a60
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl 0xe4(%rsp), %ecx
movl 0xb4(%rsp), %r8d
movl 0xb0(%rsp), %r9d
movl 0xa4(%rsp), %r11d
movl 0xa8(%rsp), %r10d
movq 0xd8(%rsp), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x178e90
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl 0xe4(%rsp), %ecx
movl 0xb4(%rsp), %r8d
movl 0xb0(%rsp), %r9d
movl 0xa4(%rsp), %r11d
movl 0xa8(%rsp), %r10d
movq 0xd8(%rsp), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x179480
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl 0xe4(%rsp), %ecx
movl 0xb4(%rsp), %r8d
movl 0xb0(%rsp), %r9d
movl 0xa4(%rsp), %r11d
movl 0xa8(%rsp), %r10d
movq 0xd8(%rsp), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x17d0b0
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl 0xe4(%rsp), %ecx
movl 0xac(%rsp), %r8d
movl 0xb4(%rsp), %r9d
movl 0xb0(%rsp), %ebx
movl 0xa4(%rsp), %r11d
movl 0xa8(%rsp), %r10d
movq 0xd8(%rsp), %rax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x17ed50
movl %eax, 0xfc(%rsp)
jmp 0x1760ad
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175679
movq 0xf0(%rsp), %rax
testb $0x1, 0x218c(%rax)
je 0x175677
movq 0xc0(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x128(%rcx), %rax
jne 0x175677
movq 0xc8(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x175677
movq 0xf0(%rsp), %rax
movq 0x170(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x175628
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x9fa40(%rip), %rcx     # 0x214fd8
cmpq (%rcx), %rax
je 0x175628
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x175628
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x175628
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
xorl %edx, %edx
callq 0x2cd00
movq 0x30(%rsp), %rdi
movq 0x10(%rax), %rcx
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %r9d
movl $0x400, %esi            # imm = 0x400
leaq 0x7a8a2(%rip), %rdx     # 0x1efec1
movb $0x0, %al
callq 0x14df0
jmp 0x175668
movq 0xf0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
xorl %edx, %edx
callq 0x2cd00
movq 0x28(%rsp), %rdi
movq 0x10(%rax), %rcx
movl $0x400, %esi            # imm = 0x400
leaq 0x7a87f(%rip), %rdx     # 0x1efee0
movb $0x0, %al
callq 0x14df0
movq 0xc8(%rsp), %rax
movl $0x1, 0x2c(%rax)
jmp 0x175679
movl $0x0, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x175762
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x175728
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
andq $0x400000, %rax         # imm = 0x400000
cmpq $0x0, %rax
jne 0x175726
movq 0xf0(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0xe4(%rsp), %edx
movq 0xd8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x174df0
cmpl $0x2, %eax
jne 0x175726
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175742
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x175740
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x175742
jmp 0x175744
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x78(%rsp)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x1756a2
movq 0x78(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x175d40
movq 0xe8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x801, %eax            # imm = 0x801
je 0x175d40
movq 0xf0(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0xe8(%rsp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, 0x70(%rsp)
jne 0x175948
cmpl $0x0, 0x74(%rsp)
jne 0x175803
jmp 0x1757c1
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x17f, 0x4(%rax)       # imm = 0x17F
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
cmpl $0x1, 0x74(%rsp)
jne 0x175869
movq 0xc8(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
je 0x175859
jmp 0x175825
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x182, 0x4(%rax)       # imm = 0x182
jmp 0x175859
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
cmpl $0x2, 0x74(%rsp)
jne 0x1758b2
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x183, 0x4(%rax)       # imm = 0x183
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
cmpl $0x3, 0x74(%rsp)
jl 0x175943
movl 0x74(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jne 0x175943
jmp 0x1758c9
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x180, 0x4(%rax)       # imm = 0x180
jmp 0x1758fd
movslq 0x74(%rsp), %rdi
callq 0x17fa30
movq %rax, %rcx
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175d3e
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
cmpl $0x1, 0x70(%rsp)
jne 0x175b40
cmpl $0x1, 0x74(%rsp)
jne 0x175a77
movq 0xe8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x1759c2
movq 0xf0(%rsp), %rax
movq 0x17b0(%rax), %rdi
movq 0xd8(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0x1759b2
jmp 0x1759c2
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x1759dd
jmp 0x175a72
jmp 0x1759df
movq 0xa0aa2(%rip), %rcx     # 0x216488
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xd8(%rsp), %rdx
callq 0x15d020
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x184, 0x4(%rax)       # imm = 0x184
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175b3e
cmpl $0x2, 0x74(%rsp)
jne 0x175b3c
movq 0xf0(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x175a9d
jmp 0x175b3a
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x175ac4
jmp 0x175b3a
jmp 0x175ac6
movq 0xa09c3(%rip), %rcx     # 0x216490
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
jmp 0x175af8
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x185, 0x4(%rax)       # imm = 0x185
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175b3c
jmp 0x175b3e
jmp 0x175b40
cmpl $0x2, 0x74(%rsp)
jne 0x175c03
movq 0xf0(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x175b66
jmp 0x175c03
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x175b8d
jmp 0x175c03
jmp 0x175b8f
movq 0xa08fa(%rip), %rcx     # 0x216490
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
jmp 0x175bc1
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x185, 0x4(%rax)       # imm = 0x185
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x17fae0
cmpl 0x74(%rsp), %eax
jne 0x175d3c
cmpl $0x40, 0x74(%rsp)
jge 0x175d3c
cmpl $0x1, 0x74(%rsp)
jne 0x175c83
movq 0xe8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x175c83
movq 0xf0(%rsp), %rax
movq 0x17b0(%rax), %rdi
movq 0xd8(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0x175c73
jmp 0x175c83
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175c85
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movl 0x74(%rsp), %edx
movl $0x181, %eax            # imm = 0x181
movl $0x184, %ecx            # imm = 0x184
cmpl $0x1, %edx
cmovel %ecx, %eax
movw %ax, %cx
movq 0xe8(%rsp), %rax
movw %cx, 0x4(%rax)
jmp 0x175cce
movslq 0x74(%rsp), %rdi
callq 0x17fa30
movq %rax, %rcx
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
cmpl $0x1, 0x74(%rsp)
jne 0x175d2c
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xd8(%rsp), %rdx
callq 0x15d020
movl $0x0, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175d3e
jmp 0x175d40
jmp 0x1760a2
movq 0xe8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x175dda
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x175dc5
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x400000, %rax         # imm = 0x400000
cmpq $0x0, %rax
jne 0x175dc5
movq 0xf0(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0xe4(%rsp), %edx
movq 0xd8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x174df0
cmpl $0x2, %eax
jne 0x175dc5
movl $0x2, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x175dc7
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x175d52
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xfd500
testb $0x1, %al
jne 0x175dfc
jmp 0x1760a0
movq 0xc8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1760a0
movq 0xc8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x17e8(%rcx), %rax
jne 0x1760a0
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1760a0
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1760a0
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1760a0
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1760a0
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1760a0
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x175eef
jmp 0x1760a0
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x175f15
jmp 0x1760a0
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0xd8(%rsp), %rdx
callq 0x178880
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x17609e
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0x17609c
movq 0x48(%rsp), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
je 0x17609c
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0xd8(%rsp), %rdx
callq 0x178880
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x17609a
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0x176098
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
je 0x176098
movq 0x48(%rsp), %rcx
movq 0xe8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rcx
movq 0xe8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0xe8(%rsp), %rax
movzwl (%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movw %cx, (%rax)
movq 0xe8(%rsp), %rax
movw $0x167, 0x4(%rax)       # imm = 0x167
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xd8(%rsp), %rdx
callq 0x15d020
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xd8(%rsp), %rdx
callq 0x15d020
movl $0x1, 0xfc(%rsp)
jmp 0x1760ad
jmp 0x17609a
jmp 0x17609c
jmp 0x17609e
jmp 0x1760a0
jmp 0x1760a2
movl $0x0, 0xfc(%rsp)
movl 0xfc(%rsp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
nopl (%rax)