// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
leaq 0xc591(%rip), %r12      # 0x10010
leaq 0xdba7(%rip), %r13      # 0x1162d
movzwl (%r14), %eax
cmpq $0x13, %rax
ja 0x4165
movl 0x4(%r14), %r15d
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x30(%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rdi
leaq 0xd934(%rip), %rsi      # 0x113ea
movl %r15d, %edx
movl %r15d, %r9d
xorl %eax, %eax
callq 0x39a0
movq 0x50(%r14), %rbp
testq %rbp, %rbp
je 0x3aea
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
movq 0x58(%r14), %r14
jmp 0x3d26
movq 0x20(%r14), %rax
leaq 0x11c02(%rip), %rcx     # 0x15700
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
leaq 0xd9ab(%rip), %rsi      # 0x114b7
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
jmp 0x3e45
movq 0x10(%r14), %rax
leaq 0x11baa(%rip), %rcx     # 0x156d0
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
leaq 0xd983(%rip), %rsi      # 0x114b7
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x18(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
jmp 0x3ca0
movq %rbx, %rdi
leaq 0xd8ee(%rip), %rsi      # 0x1145d
movl %r15d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x39a0
movq 0x20(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
cmpq $0x0, 0x28(%r14)
je 0x3bdc
xorl %r12d, %r12d
movq 0x30(%r14), %rax
movq (%rax,%r12,8), %rbp
testq %rbp, %rbp
je 0x3bd3
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
incq %r12
cmpq 0x28(%r14), %r12
jb 0x3ba8
cmpq $0x0, 0x38(%r14)
je 0x3c1a
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rbp
testq %rbp, %rbp
je 0x3c11
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
incq %r12
cmpq 0x38(%r14), %r12
jb 0x3be6
movq 0x48(%r14), %r14
movl 0x4(%r14), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
leaq 0xc3d7(%rip), %r12      # 0x10010
jmp 0x3a86
movq 0x20(%r14), %rax
leaq 0x11a47(%rip), %rcx     # 0x15690
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
leaq 0xd860(%rip), %rsi      # 0x114b7
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x28(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
movq 0x30(%r14), %r14
jmp 0x3e49
movq %rbx, %rdi
leaq 0xd80f(%rip), %rsi      # 0x114a5
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x20(%r14), %r14
jmp 0x3e49
movzwl 0x2(%r14), %eax
testb $0x8, %al
jne 0x3d89
leaq 0xd8ba(%rip), %rsi      # 0x11577
testb $0x4, %al
je 0x3d9d
jmp 0x41c0
movq %rbx, %rdi
leaq 0xd8bf(%rip), %rsi      # 0x11593
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x10(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
movq 0x18(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x3e49
jmp 0x4165
movq %rbx, %rdi
leaq 0xd78c(%rip), %rsi      # 0x114ca
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x10(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
jmp 0x3d80
movq %rbx, %rdi
leaq 0xd85c(%rip), %rsi      # 0x115d2
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x18(%r14), %r14
jmp 0x3e49
testb $0x4, %al
leaq 0xd74e(%rip), %rsi      # 0x114e0
leaq 0xd764(%rip), %rax      # 0x114fd
cmoveq %rax, %rsi
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
leaq 0xd679(%rip), %rsi      # 0x1142d
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x10(%r14), %rbp
testq %rbp, %rbp
je 0x3de5
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
testb $0x8, 0x2(%r14)
movq 0x18(%r14), %rbp
jne 0x3e10
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
jmp 0x3e23
testq %rbp, %rbp
je 0x3e23
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xcb32
movq 0x20(%r14), %rbp
movl 0x4(%rbp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a67
movq 0x28(%r14), %r14
movl 0x4(%r14), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
jmp 0x3a86
movl 0x20(%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xd564(%rip), %rsi      # 0x113d5
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39a0
leaq 0xd713(%rip), %rsi      # 0x115a6
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
cmpq $0x0, 0x20(%r14)
je 0x3ee0
leaq 0xd77f(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x28(%r14), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x20(%r14), %rbp
jb 0x3eb0
cmpq $0x0, 0x30(%r14)
je 0x4165
leaq 0xd73b(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x38(%r14), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x30(%r14), %rbp
jb 0x3ef4
jmp 0x4165
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
leaq 0xd49a(%rip), %rsi      # 0x113d5
jmp 0x4183
leaq 0xd4f8(%rip), %rsi      # 0x1143f
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
cmpq $0x0, 0x20(%r14)
je 0x3f99
leaq 0xd6cb(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x28(%r14), %rax
movq (%rax,%rbp,8), %r13
testq %r13, %r13
je 0x3f90
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x20(%r14), %rbp
jb 0x3f64
cmpq $0x0, 0x30(%r14)
je 0x4165
leaq 0xd682(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x38(%r14), %rax
movq (%rax,%rbp,8), %r13
testq %r13, %r13
je 0x3fd9
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x30(%r14), %rbp
jb 0x3fad
jmp 0x4165
movq 0x20(%r14), %rax
leaq 0x1116e(%rip), %rcx     # 0x15160
movq (%rcx,%rax,8), %rcx
leaq 0xd4ba(%rip), %rsi      # 0x114b7
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39a0
leaq 0xd59e(%rip), %rsi      # 0x115bd
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
cmpq $0x0, 0x20(%r14)
je 0x4165
leaq 0xd5ef(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x28(%r14), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x20(%r14), %rbp
jb 0x4040
jmp 0x4165
cmpb $0x1, 0x20(%r14)
jne 0x419e
leaq 0xd57b(%rip), %rsi      # 0x11602
jmp 0x41a5
leaq 0xd385(%rip), %rsi      # 0x11418
movq %rbx, %rdi
movl %r15d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x39a0
cmpq $0x0, 0x10(%r14)
je 0x4165
leaq 0xd578(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x10(%r14), %rbp
jb 0x40b7
jmp 0x4165
leaq 0xd397(%rip), %rsi      # 0x11487
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x39a0
movq 0x20(%r14), %r12
movl 0x4(%r12), %ecx
leaq 0xd520(%rip), %rsi      # 0x1162d
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a67
cmpq $0x0, 0x28(%r14)
je 0x4165
leaq 0xd4fa(%rip), %r12      # 0x1162d
xorl %ebp, %ebp
movq 0x30(%r14), %rax
movq (%rax,%rbp,8), %r13
movl 0x4(%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a67
incq %rbp
cmpq 0x28(%r14), %rbp
jb 0x4135
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%r14), %rcx
movq 0x28(%r14), %r8
leaq 0xd466(%rip), %rsi      # 0x115e9
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39a0
leaq 0xd472(%rip), %rsi      # 0x11617
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39a0
leaq 0xd352(%rip), %rdi      # 0x11519
leaq 0xd373(%rip), %rsi      # 0x11541
leaq 0xd378(%rip), %rcx      # 0x1154d
movl $0x112, %edx            # imm = 0x112
callq 0x3080