// File: /workspace/github_cpp_makefile_star2_O3/cphinton42[P]hinton-language/src/ast.cpp
// Function: print_dot_rec(Print_Buffer*, AST*)
internal void print_dot_rec(Print_Buffer *pb, AST *ast)
{
    u32 s = ast->s;
    switch(ast->type)
    {
        case AST_Type::ident_ast: {
            Ident_AST *ident_ast = static_cast<Ident_AST*>(ast);
            String str = *ident_ast->atom.str;
            print_buf(pb, "n%ld[label=\"%.*s\"];\n", s, str.count, str.data);
        } break;
        case AST_Type::decl_ast: {
            Decl_AST *decl_ast = static_cast<Decl_AST*>(ast);
            
            String str = *decl_ast->ident.atom.str;
            print_buf(pb, "n%ld[label=\"Declare %.*s\"];\nn%ld[shape=box];\n", s, str.count, str.data, s);
            if(decl_ast->decl_type)
            {
                print_dot_child(pb, decl_ast->decl_type, s);
            }
            if(decl_ast->expr)
            {
                print_dot_child(pb, decl_ast->expr, s);
            }
        } break;
        case AST_Type::block_ast: {
            Block_AST *block_ast = static_cast<Block_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"Block\"];\nn%ld[shape=box];\n", s, s);
            
            for(u64 i = 0; i < block_ast->statements.count; ++i)
            {
                print_dot_child(pb, block_ast->statements[i], s);
            }
        } break;
        case AST_Type::function_type_ast: {
            Function_Type_AST *type_ast = static_cast<Function_Type_AST*>(ast);
            print_buf(pb, "n%ld[label=\"Function Type\"];\n", s);
            
            for(u64 i = 0; i < type_ast->parameter_types.count; ++i)
            {
                if(type_ast->parameter_types[i])
                {
                    print_dot_child(pb, type_ast->parameter_types[i], s);
                }
            }
            for(u64 i = 0; i < type_ast->return_types.count; ++i)
            {
                if(type_ast->return_types[i])
                {
                    print_dot_child(pb, type_ast->return_types[i], s);
                }
            }
        } break;
        case AST_Type::function_ast: {
            Function_AST *function_ast = static_cast<Function_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"Function\"];\nn%ld[shape=box];\n", s, s);
            
            print_dot_child(pb, function_ast->prototype, s);
            for(u64 i = 0; i < function_ast->param_names.count; ++i)
            {
                if(function_ast->param_names[i])
                {
                    print_dot_child(pb, function_ast->param_names[i], s);
                }
            }
            for(u64 i = 0; i < function_ast->default_values.count; ++i)
            {
                if(function_ast->default_values[i])
                {
                    print_dot_child(pb, function_ast->default_values[i], s);
                }
            }
            print_dot_child(pb, function_ast->block, s);
        } break;
        case AST_Type::function_call_ast: {
            Function_Call_AST *call_ast = static_cast<Function_Call_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"function call\"];\n", s);
            print_dot_child(pb, call_ast->function, s);
            for(u64 i = 0; i < call_ast->args.count; ++i)
            {
                print_dot_child(pb, call_ast->args[i], s);
            }
        } break;
        case AST_Type::access_ast: {
            Access_AST *access_ast = static_cast<Access_AST*>(ast);
            print_buf(pb, "n%ld[label=\".\"];\n", s);
            print_dot_child(pb, access_ast->lhs, s);
        } break;
        case AST_Type::binary_operator_ast: {
            Binary_Operator_AST *bin_ast = static_cast<Binary_Operator_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"%s\"];\n", s, binary_operator_names[(u64)bin_ast->op]);
            print_dot_child(pb, bin_ast->lhs, s);
            print_dot_child(pb, bin_ast->rhs, s);
        } break;
        case AST_Type::number_ast: {
            Number_AST *number_ast = static_cast<Number_AST*>(ast);
            print_buf(pb, "n%ld[label=\"%.*s\"];\n", s, (u32)number_ast->literal.count, number_ast->literal.data);
        } break;
        case AST_Type::while_ast: {
            While_AST *while_ast = static_cast<While_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"while\"];\n", s);
            print_dot_child(pb, while_ast->guard, s);
            print_dot_child(pb, while_ast->body, s);
        } break;
        case AST_Type::for_ast: {
            For_AST *for_ast = static_cast<For_AST*>(ast);
            
            if(for_ast->flags & FOR_FLAG_OVER_ARRAY)
            {
                if(for_ast->flags & FOR_FLAG_BY_POINTER)
                {
                    print_buf(pb, "n%ld[label=\"for &(array)\"];\n", s);
                }
                else
                {
                    print_buf(pb, "n%ld[label=\"for (array)\"];\n", s);
                }
            }
            else
            {
                assert(!(for_ast->flags & FOR_FLAG_BY_POINTER));
                print_buf(pb, "n%ld[label=\"for (range)\"];\n", s);
            }
            print_buf(pb, "n%ld[shape=box];\n", s);
            
            if(for_ast->induction_var)
            {
                print_dot_child(pb, for_ast->induction_var, s);
            }
            if(for_ast->flags & FOR_FLAG_OVER_ARRAY)
            {
                if(for_ast->index_var)
                {
                    print_dot_child(pb, for_ast->index_var, s);
                }
                print_dot_child(pb, for_ast->array_expr, s);
            }
            else
            {
                print_dot_child(pb, for_ast->low_expr, s);
                print_dot_child(pb, for_ast->high_expr, s);
            }
            
            print_dot_child(pb, for_ast->body, s);
        } break;
        case AST_Type::if_ast: {
            If_AST *if_ast = static_cast<If_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"if\"];\n", s);
            print_dot_child(pb, if_ast->guard, s);
            print_dot_child(pb, if_ast->then_block, s);
            if(if_ast->else_block)
            {
                print_dot_child(pb, if_ast->else_block, s);
            }
        } break;
        case AST_Type::struct_ast: {
            Struct_AST *struct_ast = static_cast<Struct_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"struct\"];\n", s);
            for(u64 i = 0; i < struct_ast->constants.count; ++i)
            {
                print_dot_child(pb, struct_ast->constants[i], s);
            }
            for(u64 i = 0; i < struct_ast->fields.count; ++i)
            {
                print_dot_child(pb, struct_ast->fields[i], s);
            }
        } break;
        case AST_Type::enum_ast: {
            Enum_AST *enum_ast = static_cast<Enum_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"enum\"];\n", s);
            for(u64 i = 0; i < enum_ast->values.count; ++i)
            {
                print_dot_child(pb, enum_ast->values[i], s);
            }
        } break;
        case AST_Type::assign_ast: {
            Assign_AST *assign_ast = static_cast<Assign_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"%s\"];\n", s, assign_names[(u64)assign_ast->assign_type]);
            print_dot_child(pb, assign_ast->lhs, s);
            print_dot_child(pb, assign_ast->rhs, s);
        } break;
        case AST_Type::unary_ast: {
            Unary_Operator_AST *unary_ast = static_cast<Unary_Operator_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"%s\"];\n", s, unary_operator_names[(u64)unary_ast->op]);
            print_dot_child(pb, unary_ast->operand, s);
        } break;
        case AST_Type::return_ast: {
            Return_AST *return_ast = static_cast<Return_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"return\"];\n", s);
            print_dot_child(pb, return_ast->expr, s);
        } break;
        case AST_Type::primitive_ast: {
            Primitive_AST *primitive_ast = static_cast<Primitive_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"%s\"];\n", s, primitive_names[(u64)primitive_ast->primitive]);
        } break;
        case AST_Type::string_ast: {
            String_AST *string_ast = static_cast<String_AST*>(ast);
            
            print_buf(pb, "n%ld[label=\"\\\"%.*s\\\"\"];\n", s, string_ast->literal.count, string_ast->literal.data);
        } break;
        case AST_Type::bool_ast: {
            Bool_AST *bool_ast = static_cast<Bool_AST*>(ast);
            if(bool_ast->value)
            {
                print_buf(pb, "n%ld[label=\"true\"];\n", s);
            }
            else
            {
                print_buf(pb, "n%ld[label=\"false\"];\n", s);
            }
        } break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc687(%rip), %r12      # 0x10010
leaq 0xdc6b(%rip), %r13      # 0x115fb
movzwl (%r15), %eax
cmpq $0x13, %rax
ja 0x406f
movl 0x4(%r15), %r14d
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x30(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rdi
leaq 0xd9f8(%rip), %rsi      # 0x113b8
movl %r14d, %edx
movl %r14d, %r9d
xorl %eax, %eax
callq 0x38a8
movq 0x50(%r15), %rbp
testq %rbp, %rbp
je 0x39f4
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x58(%r15), %r15
jmp 0x3c26
movq 0x20(%r15), %rax
leaq 0x11cf8(%rip), %rcx     # 0x15700
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
leaq 0xda6f(%rip), %rsi      # 0x11485
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
jmp 0x3d45
movq 0x10(%r15), %rax
leaq 0x11ca0(%rip), %rcx     # 0x156d0
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
leaq 0xda47(%rip), %rsi      # 0x11485
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x18(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
jmp 0x3ba0
movq %rbx, %rdi
leaq 0xd9b2(%rip), %rsi      # 0x1142b
movl %r14d, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x38a8
movq 0x20(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x28(%r15), %rax
testq %rax, %rax
je 0x3aeb
xorl %r12d, %r12d
movq 0x30(%r15), %rcx
movq (%rcx,%r12,8), %rbp
testq %rbp, %rbp
je 0x3ae3
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x28(%r15), %rax
incq %r12
cmpq %rax, %r12
jb 0x3ab4
movq 0x38(%r15), %rax
testq %rax, %rax
je 0x3b2e
xorl %r12d, %r12d
movq 0x40(%r15), %rcx
movq (%rcx,%r12,8), %rbp
testq %rbp, %rbp
je 0x3b26
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x38(%r15), %rax
incq %r12
cmpq %rax, %r12
jb 0x3af7
movq 0x48(%r15), %r15
leaq 0xc4d7(%rip), %r12      # 0x10010
jmp 0x3d49
movq 0x20(%r15), %rax
leaq 0x11b47(%rip), %rcx     # 0x15690
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
leaq 0xd92e(%rip), %rsi      # 0x11485
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x28(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x30(%r15), %r15
jmp 0x3d49
movq %rbx, %rdi
leaq 0xd8dd(%rip), %rsi      # 0x11473
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x20(%r15), %r15
jmp 0x3d49
movzwl 0x2(%r15), %eax
testb $0x8, %al
jne 0x3c89
leaq 0xd988(%rip), %rsi      # 0x11545
testb $0x4, %al
je 0x3c9d
jmp 0x40ca
movq %rbx, %rdi
leaq 0xd98d(%rip), %rsi      # 0x11561
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x10(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x18(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x3d49
jmp 0x406f
movq %rbx, %rdi
leaq 0xd85a(%rip), %rsi      # 0x11498
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x10(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
jmp 0x3c80
movq %rbx, %rdi
leaq 0xd92a(%rip), %rsi      # 0x115a0
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x18(%r15), %r15
jmp 0x3d49
testb $0x4, %al
leaq 0xd81c(%rip), %rsi      # 0x114ae
leaq 0xd832(%rip), %rax      # 0x114cb
cmoveq %rax, %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
leaq 0xd747(%rip), %rsi      # 0x113fb
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x10(%r15), %rbp
testq %rbp, %rbp
je 0x3ce5
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
testb $0x8, 0x2(%r15)
movq 0x18(%r15), %rbp
jne 0x3d10
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
jmp 0x3d23
testq %rbp, %rbp
je 0x3d23
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xc996
movq 0x20(%r15), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3971
movq 0x28(%r15), %r15
movl 0x4(%r15), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
jmp 0x3990
movl 0x20(%r15), %ecx
movq 0x28(%r15), %r8
leaq 0xd632(%rip), %rsi      # 0x113a3
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38a8
leaq 0xd7e1(%rip), %rsi      # 0x11574
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
cmpq $0x0, 0x20(%r15)
je 0x3de0
leaq 0xd84d(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x28(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
incq %rbp
cmpq 0x20(%r15), %rbp
jb 0x3db0
cmpq $0x0, 0x30(%r15)
je 0x406f
leaq 0xd809(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x38(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
incq %rbp
cmpq 0x30(%r15), %rbp
jb 0x3df4
jmp 0x406f
movq 0x20(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
leaq 0xd568(%rip), %rsi      # 0x113a3
jmp 0x408d
leaq 0xd5c6(%rip), %rsi      # 0x1140d
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x3e9e
leaq 0xd797(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x28(%r15), %rcx
movq (%rcx,%rbp,8), %r13
testq %r13, %r13
je 0x3e96
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
movq 0x20(%r15), %rax
incq %rbp
cmpq %rax, %rbp
jb 0x3e66
movq 0x30(%r15), %rax
testq %rax, %rax
je 0x406f
leaq 0xd749(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x38(%r15), %rcx
movq (%rcx,%rbp,8), %r13
testq %r13, %r13
je 0x3ee4
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
movq 0x30(%r15), %rax
incq %rbp
cmpq %rax, %rbp
jb 0x3eb4
jmp 0x406f
movq 0x20(%r15), %rax
leaq 0x11264(%rip), %rcx     # 0x15160
movq (%rcx,%rax,8), %rcx
leaq 0xd57e(%rip), %rsi      # 0x11485
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38a8
leaq 0xd662(%rip), %rsi      # 0x1158b
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
cmpq $0x0, 0x20(%r15)
je 0x406f
leaq 0xd6b3(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x28(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
incq %rbp
cmpq 0x20(%r15), %rbp
jb 0x3f4a
jmp 0x406f
cmpb $0x1, 0x20(%r15)
jne 0x40a8
leaq 0xd63f(%rip), %rsi      # 0x115d0
jmp 0x40af
leaq 0xd449(%rip), %rsi      # 0x113e6
movq %rbx, %rdi
movl %r14d, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x38a8
cmpq $0x0, 0x10(%r15)
je 0x406f
leaq 0xd63c(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x18(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
incq %rbp
cmpq 0x10(%r15), %rbp
jb 0x3fc1
jmp 0x406f
leaq 0xd45b(%rip), %rsi      # 0x11455
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x38a8
movq 0x20(%r15), %r12
movl 0x4(%r12), %ecx
leaq 0xd5e4(%rip), %rsi      # 0x115fb
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3971
cmpq $0x0, 0x28(%r15)
je 0x406f
leaq 0xd5be(%rip), %r12      # 0x115fb
xorl %ebp, %ebp
movq 0x30(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3971
incq %rbp
cmpq 0x28(%r15), %rbp
jb 0x403f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%r15), %rcx
movq 0x28(%r15), %r8
leaq 0xd52a(%rip), %rsi      # 0x115b7
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38a8
leaq 0xd536(%rip), %rsi      # 0x115e5
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38a8
leaq 0xd416(%rip), %rdi      # 0x114e7
leaq 0xd437(%rip), %rsi      # 0x1150f
leaq 0xd43c(%rip), %rcx      # 0x1151b
movl $0x112, %edx            # imm = 0x112
callq 0x3080