LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: html
static
void
html (FILE * f, const char * title)
{
    int i;

    fprintf(f, "<html><head>");
    if (0 != title) {
        fprintf(f, "<title>%s</title>", title);
    }
    fprintf(f,
            "</head><body>"
            "<table"
                " align=\"center\" border=\"1\""
                " cellpadding=\"3\" cellspacing=\"1\""
                " rules=\"all\""
            " >\n");

    for (i = 0; i < 81; ++i) {
        if (0 == i % 9) {
            fprintf(f, "<tr>");
        }
        fprintf(f, "<td>");
        if (IS_EMPTY(i)) {
            fprintf(f, "&nbsp;&nbsp;&nbsp;");
        } else {
            fprintf(f, "&nbsp;%d&nbsp;", GET_DIGIT(board[i]));
        }
        fprintf(f, "</td>");
        if (8 == i % 9) {
            fprintf(f, "</tr>\n");
        }
    }
    fprintf(f,
            "</table>"
            "</body>"
            "</html>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5cf8(%rip), %rsi      # 0xd873
movb $0x0, %al
callq 0x2200
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x7ba0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5ce7(%rip), %rsi      # 0xd880
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x5ce7(%rip), %rsi      # 0xd892
movb $0x0, %al
callq 0x2200
movl $0x0, -0x14(%rbp)
cmpl $0x51, -0x14(%rbp)
jge 0x7c9a
movl -0x14(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %edx, %eax
jne 0x7be6
movq -0x8(%rbp), %rdi
leaq 0x5d10(%rip), %rsi      # 0xd8ef
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x5d03(%rip), %rsi      # 0xd8f4
movb $0x0, %al
callq 0x2200
movslq -0x14(%rbp), %rcx
leaq 0xa8ad(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7c29
movq -0x8(%rbp), %rdi
leaq 0x5cd9(%rip), %rsi      # 0xd8f9
movb $0x0, %al
callq 0x2200
jmp 0x7c52
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xa878(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %edx
andl $0xf0000, %edx          # imm = 0xF0000
sarl $0x10, %edx
leaq 0x5cc1(%rip), %rsi      # 0xd90c
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x5cbe(%rip), %rsi      # 0xd91b
movb $0x0, %al
callq 0x2200
movl -0x14(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl $0x8, %eax
cmpl %edx, %eax
jne 0x7c8a
movq -0x8(%rbp), %rdi
leaq 0x5c9e(%rip), %rsi      # 0xd921
movb $0x0, %al
callq 0x2200
jmp 0x7c8c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7bb9
movq -0x8(%rbp), %rdi
leaq 0x5c83(%rip), %rsi      # 0xd928
movb $0x0, %al
callq 0x2200
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: clear_status
static
void
clear_status (void)
{
    move(STATUS_LINE, LEFT_LEFT);
    wclrtoeol(stdscr);
    move_to(curx, cury);
    have_status = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x92ed(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x14, %esi
xorl %edx, %edx
callq 0x22b0
movq 0x92d7(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
callq 0x22c0
movl 0xaced(%rip), %edi      # 0x129fc
movl 0xaceb(%rip), %esi      # 0x12a00
callq 0x5d10
movl $0x0, 0xace0(%rip)      # 0x12a04
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: move_next
void
static
move_next (void)
{
    int is_loop = 0;
    do {
        if (curx < 8) {
            move_to(curx + 1, cury);
        } else if (cury < 8) {
            move_to(0, cury + 1);
        } else {
            move_to(0, 0);
            if (is_loop++ > 0) {
                /* We can get here if the user attempts to load a fully
                 * populated board. In that case it's better to break.  */
                break;
            }
        }
     } while (IS_FIXED(INDEX(cury, curx)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x8, 0xaab6(%rip)      # 0x129fc
jge 0x7f5e
movl 0xaaae(%rip), %edi      # 0x129fc
addl $0x1, %edi
movl 0xaaa9(%rip), %esi      # 0x12a00
callq 0x5d10
jmp 0x7f98
cmpl $0x8, 0xaa9b(%rip)      # 0x12a00
jge 0x7f79
movl 0xaa93(%rip), %esi      # 0x12a00
addl $0x1, %esi
xorl %edi, %edi
callq 0x5d10
jmp 0x7f96
xorl %esi, %esi
movl %esi, %edi
callq 0x5d10
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
jle 0x7f94
jmp 0x7fbe
jmp 0x7f96
jmp 0x7f98
jmp 0x7f9a
imull $0x9, 0xaa5f(%rip), %eax # 0x12a00
addl 0xaa55(%rip), %eax      # 0x129fc
movslq %eax, %rcx
leaq 0xa4ff(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
jne 0x7f3f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: is_complete
static
int
is_complete (void)
{
    int i;
    for (i = 0; i < 81 && !IS_EMPTY(i); ++i) {
        /* counting the non-empty squares. */
    }
   return (81 == i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x51, -0x4(%rbp)
movb %al, -0x5(%rbp)
jge 0x8009
movslq -0x4(%rbp), %rcx
leaq 0xa4bf(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
xorb $-0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x8012
jmp 0x801f
jmp 0x8014
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7fdb
movl $0x51, %eax
cmpl -0x4(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: fillx
static
void
fillx(int idx, int digit)
{
    /* Nothing to do if digit already set or cleared */
    if (DIGIT(idx) == digit) {
        return;
    }
    if (0 != digit && IS_EMPTY(idx)) {
        board[idx] = SET_DIGIT(digit) | SET_INDEX(idx);
        update(idx);
        add_move(idx, digit, 0);
    } else {
        /* Clearing or overwriting is more time consuming */
        add_move(idx, 0, 0);
        reapply();

        /* Always apply moves - even in invalid */
        if (0 != digit) {
            if (idx_history > 0) {
                history[idx_history - 1] |= SET_DIGIT(digit);
                reapply();
            } else {
                beep();
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xa2f7(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %eax
andl $0xf0000, %eax          # imm = 0xF0000
sarl $0x10, %eax
cmpl -0x8(%rbp), %eax
jne 0x81ce
jmp 0x8277
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
je 0x8220
movslq -0x4(%rbp), %rcx
leaq 0xa2d0(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8220
movl -0x8(%rbp), %edx
shll $0x10, %edx
orl -0x4(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0xa2aa(%rip), %rax      # 0x124b0
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
callq 0x5bd0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x65a0
jmp 0x8277
movl -0x4(%rbp), %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x65a0
callq 0x2d20
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
je 0x8275
cmpl $0x0, 0xa3e5(%rip)      # 0x12624
jle 0x826e
movl -0x8(%rbp), %edx
shll $0x10, %edx
movl 0xa3d7(%rip), %eax      # 0x12624
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xa3d6(%rip), %rax      # 0x12630
orl (%rax,%rcx,4), %edx
leaq 0xa3cc(%rip), %rax      # 0x12630
movl %edx, (%rax,%rcx,4)
callq 0x2d20
jmp 0x8273
callq 0x20c0
jmp 0x8275
jmp 0x8277
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: fix
static
int
fix (void)
{
    int i;

    if (0 == reapply()) {
        compress(idx_history);
        for (i = 0; i < idx_history; ++i) {
            history[i] |= FIXED;
        }
        reapply();
        render();
        if (idx_history < 81 && IS_FIXED(INDEX(cury, curx))) {
            move_next();
        } else {
            move_to(curx, cury);
        }
        return 0;
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2d20
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8337
movl 0xa385(%rip), %edi      # 0x12624
callq 0x6660
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xa370(%rip), %eax      # 0x12624
jge 0x82df
movslq -0x8(%rbp), %rcx
leaq 0xa36f(%rip), %rax      # 0x12630
movl (%rax,%rcx,4), %edx
orl $0x100000, %edx         # imm = 0x100000
leaq 0xa35f(%rip), %rax      # 0x12630
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x82ab
callq 0x2d20
callq 0x7d30
cmpl $0x51, 0xa334(%rip)     # 0x12624
jge 0x831d
imull $0x9, 0xa707(%rip), %eax # 0x12a00
addl 0xa6fd(%rip), %eax      # 0x129fc
movslq %eax, %rcx
leaq 0xa1a7(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0x831d
callq 0x7f30
jmp 0x832e
movl 0xa6d9(%rip), %edi      # 0x129fc
movl 0xa6d7(%rip), %esi      # 0x12a00
callq 0x5d10
movl $0x0, -0x4(%rbp)
jmp 0x833e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: write_template
static
void
write_template (void)
{
    if (0 == get_filename(templatefile,
                            sizeof(templatefile),
                            TEMPLATE_FALLBACK,
                            "Write template")) {

            const char * p = trim_filename(templatefile,
                                            sizeof(templatefile));

        if (p != NULL && *p) {
            if (0 == write_default_template(p)) {
                status_message("Template file successfully created!");
            } else {
                beep_status_message("Template file exists"
                                    " or write error occurred!");
            }
        } else {
            beep_status_message("No valid file name found!");
        }
    } else {
        status_message("Write default template operation aborted by the user.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa981(%rip), %rdi      # 0x12d00
movl $0x1000, %esi           # imm = 0x1000
leaq 0x5887(%rip), %rdx      # 0xdc12
leaq 0x587a(%rip), %rcx      # 0xdc0c
callq 0x8710
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8402
leaq 0xa95a(%rip), %rdi      # 0x12d00
movl $0x1000, %esi           # imm = 0x1000
callq 0x8760
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x83f4
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x83f4
movq -0x8(%rbp), %rdi
callq 0x3d20
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x83e6
leaq 0x583c(%rip), %rdi      # 0xdc1b
callq 0x86e0
jmp 0x83f2
leaq 0x5852(%rip), %rdi      # 0xdc3f
callq 0x8350
jmp 0x8400
leaq 0x5872(%rip), %rdi      # 0xdc6d
callq 0x8350
jmp 0x840e
leaq 0x587e(%rip), %rdi      # 0xdc87
callq 0x86e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: open_board
static
void
open_board (void)
{
    if (0 == get_filename(userfile,
                          sizeof(userfile),
                          DEFAULT_BOARD_NAME,
                          "Open board")) {

        const char * p = trim_filename(userfile,
                                       sizeof(userfile));

        if (p != NULL && *p) {
            if (opened != NULL) {
                fclose(opened);
                opened = NULL;
            }
            opened = fopen(p, "r");
            if (opened != NULL) {
                load_board();
            } else {
                set_status("Error: failed to open the board!");
            }
        } else {
            beep_status_message("No valid file name found!");
        }
    } else {
        status_message("Open board operation aborted by the user.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8fa1(%rip), %rdi      # 0x113d0
movl $0x1000, %esi           # imm = 0x1000
leaq 0x5646(%rip), %rdx      # 0xda81
leaq 0x5a36(%rip), %rcx      # 0xde78
callq 0x8710
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x84e0
leaq 0x8f76(%rip), %rdi      # 0x113d0
movl $0x1000, %esi           # imm = 0x1000
callq 0x8760
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x84d2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x84d2
cmpq $0x0, 0xa805(%rip)      # 0x12c88
je 0x849c
movq 0xa7fc(%rip), %rdi      # 0x12c88
callq 0x20d0
movq $0x0, 0xa7ec(%rip) # 0x12c88
movq -0x8(%rbp), %rdi
leaq 0x5595(%rip), %rsi      # 0xda3c
callq 0x22a0
movq %rax, 0xa7d5(%rip)      # 0x12c88
cmpq $0x0, 0xa7cd(%rip)      # 0x12c88
je 0x84c4
callq 0x4fa0
jmp 0x84d0
leaq 0x59b8(%rip), %rdi      # 0xde83
callq 0x32f0
jmp 0x84de
leaq 0x5794(%rip), %rdi      # 0xdc6d
callq 0x8350
jmp 0x84ec
leaq 0x59bd(%rip), %rdi      # 0xdea4
callq 0x86e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: save_board
static
void
save_board (void)
{
    const char * p;
    FILE * f;

    /* Read character input (raw processing mode) */

    if (0 == get_filename(userfile,
                          sizeof(userfile),
                          DEFAULT_BOARD_NAME,
                          "Save board")) {

        p = trim_filename(userfile,
                          sizeof(userfile));

        if (p != NULL && *p) {
            if ('|' == userfile[0]) {
                f = popen(p, "w");
                if (0 != f) {
                    print(f, title);
                    pclose(f);
                }
            } else {
                /* Append for standard formats, else separate file */
                switch (opt_format) {
                    case fCompact:
                    case fStandard:
                        f = fopen(p, "a");
                        break;
                    default:
                        f = fopen(p, "w");
                        break;
                }
                if (0 != f) {
                    print(f, title);
                    fclose(f);
                }
            }
            if (0 == f) {
                set_status("Error: failed to write the file!");
            }
        } else {
            set_status("Error: no valid file name found!");
        }
    } else {
        status_message("Save board operation aborted by the user.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8ec1(%rip), %rdi      # 0x113d0
movl $0x1000, %esi           # imm = 0x1000
leaq 0x5566(%rip), %rdx      # 0xda81
leaq 0x59ac(%rip), %rcx      # 0xdece
callq 0x8710
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8628
leaq 0x8e96(%rip), %rdi      # 0x113d0
movl $0x1000, %esi           # imm = 0x1000
callq 0x8760
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x861a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x861a
movsbl 0x8e66(%rip), %ecx      # 0x113d0
movl $0x7c, %eax
cmpl %ecx, %eax
jne 0x85aa
movq -0x8(%rbp), %rdi
leaq 0x4ad4(%rip), %rsi      # 0xd052
callq 0x2290
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x85a8
movq -0x10(%rbp), %rdi
leaq 0x9e86(%rip), %rsi      # 0x12420
callq 0x4670
movq -0x10(%rbp), %rdi
callq 0x2140
jmp 0x8604
movl 0x9e34(%rip), %eax      # 0x123e4
subl $0x1, %eax
ja 0x85cd
jmp 0x85b7
movq -0x8(%rbp), %rdi
leaq 0x5917(%rip), %rsi      # 0xded9
callq 0x22a0
movq %rax, -0x10(%rbp)
jmp 0x85e1
movq -0x8(%rbp), %rdi
leaq 0x4a7a(%rip), %rsi      # 0xd052
callq 0x22a0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x8602
movq -0x10(%rbp), %rdi
leaq 0x9e2c(%rip), %rsi      # 0x12420
callq 0x4670
movq -0x10(%rbp), %rdi
callq 0x20d0
jmp 0x8604
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x8618
leaq 0x58c8(%rip), %rdi      # 0xdedb
callq 0x32f0
jmp 0x8626
leaq 0x58db(%rip), %rdi      # 0xdefc
callq 0x32f0
jmp 0x8634
leaq 0x58ee(%rip), %rdi      # 0xdf1d
callq 0x86e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: rename_board_title
static
void
rename_board_title (void)
{
    char new_title[80];
    new_title[0]='\0';
    if (0 == get_title(new_title,
                        sizeof(new_title),
                        title,
                        "Rename the board title")) {
        const char *    nt;
        size_t          ts = sizeof(new_title);
        if (ts > sizeof(title)) {
            ts = sizeof(title);
        }
        nt = trim_titlename(new_title, ts);
        if (nt != NULL && *nt != '\0') {
            strcpy(title, nt);
            write_title(title);
        }
        move_to(curx, cury);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb $0x0, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x50, %esi
leaq 0x9dc4(%rip), %rdx      # 0x12420
leaq 0x58e4(%rip), %rcx      # 0xdf47
callq 0xa3f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x86d8
movq $0x50, -0x60(%rbp)
cmpq $0x50, -0x60(%rbp)
jbe 0x8687
movq $0x50, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xa440
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x86c7
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x86c7
movq -0x58(%rbp), %rsi
leaq 0x9d6a(%rip), %rdi      # 0x12420
callq 0x2050
leaq 0x9d5e(%rip), %rdi      # 0x12420
callq 0x74b0
movl 0xa32f(%rip), %edi      # 0x129fc
movl 0xa32d(%rip), %esi      # 0x12a00
callq 0x5d10
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: status_message
static
void
status_message (const char * txt)
{
    beep();
    set_status(txt);
    usleep(2000000);
    clear_status();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x20c0
movq -0x8(%rbp), %rdi
callq 0x32f0
movl $0x1e8480, %edi         # imm = 0x1E8480
callq 0x2370
callq 0x7ce0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: get_filename
static
int
get_filename (char *        buffer,
              size_t        buffsize,
              const char *  default_name,
              const char *  operation_name)
{
    return get_string(buffer,
                      buffsize,
                      "Filename:",
                      default_name,
                      operation_name,
                      '$',
                      get_filepath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x557e(%rip), %rdx      # 0xdcbd
movl $0x24, %r9d
leaq 0x364(%rip), %rax       # 0x8ab0
movq %rax, (%rsp)
callq 0x8790
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: el_is_changeable_prompt_char
static
int
el_is_changeable_prompt_char (edit_t *  ep)
{
    return (('%' != ep->prompt &&
             '$' != ep->prompt)
            && ('|' == ep->ch ||
                '>' == ep->ch));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl $0x25, %ecx
cmpl 0x44(%rdx), %ecx
movb %al, -0x9(%rbp)
je 0x9129
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl $0x24, %ecx
cmpl 0x44(%rdx), %ecx
movb %al, -0x9(%rbp)
je 0x9129
movq -0x8(%rbp), %rdx
movb $0x1, %al
movl $0x7c, %ecx
cmpl 0x54(%rdx), %ecx
movb %al, -0xa(%rbp)
je 0x9123
movq -0x8(%rbp), %rcx
movl $0x3e, %eax
cmpl 0x54(%rcx), %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: el_show_actual_char_with_highlight
static
void
el_show_actual_char_with_highlight (edit_t *    ep)
{
    if (ep->ins_mode) {
        /* Insert mode */
        el_show_actual_char(ep);
    } else {
        /* Overwrite mode */
        el_highlight_in_overwrite_mode(ep);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x9d81
movq -0x8(%rbp), %rdi
callq 0x9d90
jmp 0x9d8a
movq -0x8(%rbp), %rdi
callq 0x9e90
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: el_show_actual_char
static
void
el_show_actual_char (edit_t *  ep)
{
    if (ep->m_0 <= ep->m_1 &&
        ep->m_1 <= ep->ecp &&
        ep->ecp <= ep->ecn) {

        int first_invisible = ep->m_1 + ep->x_mv;

        if (ep->ecp < first_invisible) {
            /* Display the character */
            mvaddch(ep->efy,
                    ep->ecp - ep->m_1 + ep->x_1,
                    ep->eb[ep->ecp]);
        } else {
            if (ep->ecp != first_invisible ||
                ep->eb[ep->ecp] != '\0') {
                /* This should never happen. */
                beep();
            }
        }
    } else {
        /* This should never happen. */
        beep();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jg 0x9e78
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jg 0x9e78
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jg 0x9e78
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x38(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x9e4b
movq 0x71dc(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x8(%rbp), %rax
subl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
addl 0x2c(%rax), %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x9e27
jmp 0x9e49
movq 0x71aa(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x24(%rcx), %rcx
movsbl (%rax,%rcx), %esi
callq 0x22e0
jmp 0x9e76
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x9e6f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x24(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x9e74
callq 0x20c0
jmp 0x9e76
jmp 0x9e7d
callq 0x20c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: el_highlight_in_overwrite_mode
static
void
el_highlight_in_overwrite_mode (edit_t *    ep)
{
    if (!ep->ins_mode) {
        /* Overwrite mode, highlight the character at the current position. */
        attron(A_BOLD);
        el_show_actual_char(ep);
        attroff(A_BOLD);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x9edf
movq 0x712b(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %eax, %eax
movl %eax, %edx
callq 0x21b0
movq -0x8(%rbp), %rdi
callq 0x9d90
movq 0x710a(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %eax, %eax
movl %eax, %edx
callq 0x2340
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: trim_string
static
const char * 
trim_string (const char *   buffer,
             size_t         buffsize,
             const char *   prefixes)
{
    const char * p = buffer;
    if (p && buffsize > 0) {
        if (prefixes != NULL &&
            strchr(prefixes,*p) != NULL) {
            ++p;
            --buffsize;
        }
        while (buffsize > 0 && ' ' == *p) {
            ++p;
            --buffsize;
        }
    }
    if (buffsize == 0) {
        p = NULL;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa3ca
cmpq $0x0, -0x10(%rbp)
jbe 0xa3ca
cmpq $0x0, -0x18(%rbp)
je 0xa383
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
callq 0x2110
cmpq $0x0, %rax
je 0xa383
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa385
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
jbe 0xa3a5
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x20, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xa3ae
jmp 0xa3c8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa385
jmp 0xa3ca
cmpq $0x0, -0x10(%rbp)
jne 0xa3d9
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: get_title
static
int
get_title (char *           buffer,
           size_t           buffsize,
           const char *     default_name,
           const char *     operation_name)
{
    return get_string (buffer,
                       buffsize,
                       "Title:",
                       default_name,
                       operation_name,
                       '%',
                       NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x3b3f(%rip), %rdx      # 0xdf5e
movl $0x25, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x8790
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/ac_automaton/test/test_ac_automaton.c
// Function: judge
boolean judge(ac_tree_node *actn, ac_tree_node *failed) {
    if (actn->failed == failed) {
        return T;
    } else {
        print_err("Error at %p failed->%p, want failed->%p\n", actn, failed,
                  actn->failed);
        return F;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x227c
leaq 0xdb3(%rip), %rax       # 0x3028
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x22a6
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xee2(%rip), %rdi       # 0x3175
movb $0x0, %al
callq 0x1900
leaq 0xd8b(%rip), %rax       # 0x302c
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/voxel_space.c
// Function: shade_pixel
static inline scg_pixel_t shade_pixel(scg_pixel_t src, float32_t t) {
    float32_t r = (float32_t)src.data.r;
    float32_t g = (float32_t)src.data.g;
    float32_t b = (float32_t)src.data.b;

    r += t * (float32_t)(255.0f - r);
    g += t * (float32_t)(255.0f - g);
    b += t * (float32_t)(255.0f - b);

    return scg_pixel_new_rgb((uint8_t)r, (uint8_t)g, (uint8_t)b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movzbl -0x6(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x10(%rbp)
movzbl -0x7(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x14(%rbp)
movzbl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss 0xc17(%rip), %xmm2      # 0x800c
movaps %xmm2, %xmm3
subss %xmm1, %xmm3
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
movaps %xmm2, %xmm3
subss %xmm1, %xmm3
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
subss %xmm1, %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
cvttss2si -0x18(%rbp), %eax
movb %al, -0x4(%rbp)
cvttss2si -0x14(%rbp), %eax
movb %al, -0x3(%rbp)
cvttss2si -0x10(%rbp), %eax
movb %al, -0x2(%rbp)
movb $-0x1, -0x1(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/voxel_space.c
// Function: draw_vertical_line
static inline void draw_vertical_line(scg_image_t *draw_target, int x0, int y0,
                                      int y1, scg_pixel_t color) {
    if (y0 < 0)
        y0 = 0;
    if (y0 > y1)
        return;

    int w = draw_target->width;
    uint32_t pixel = color.packed;

    int i = scg_pixel_index_from_xy(x0, y0, w);
    for (int y = y0; y < y1; y++) {
        draw_target->pixels[i] = pixel;
        i += w;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x7492
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x749c
jmp 0x74ec
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
imull -0x20(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x74ec
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x74be
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/init.c
// Function: main
int main(int argc, char *argv[])
{
	int memfd;
	void *mapped_base;
	int jesd_phase; // jesd phase readback value

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map one page of memory into user space such that the device is in that page, but it may not
	// be at the start of the page

	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, SPI_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}

	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	jesd_phase = init_tx(mapped_base);
	printf("%d\n",jesd_phase);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */

	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1db7(%rip), %rdi      # 0x3004
movl $0x101002, %esi         # imm = 0x101002
movb $0x0, %al
callq 0x10e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1277
leaq 0x1da4(%rip), %rdi      # 0x300d
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movl -0x14(%rbp), %r8d
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x3, %edx
movl $0x11, %ecx
movl $0x64000000, %r9d       # imm = 0x64000000
callq 0x1070
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x12c0
leaq 0x1d71(%rip), %rdi      # 0x3023
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movq -0x20(%rbp), %rdi
callq 0x1f70
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0x1f87(%rip), %rdi      # 0x325d
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x10d0
cmpl $-0x1, %eax
jne 0x1305
leaq 0x1d51(%rip), %rdi      # 0x3048
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movl -0x14(%rbp), %edi
callq 0x10b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_SOAP_ENV__Header
SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize__wsa__MessageID(soap, &a->wsa__MessageID);
	soap_serialize_PointerTo_wsa__RelatesTo(soap, &a->wsa__RelatesTo);
	soap_serialize_PointerTo_wsa__From(soap, &a->wsa__From);
	soap_serialize_PointerTo_wsa__ReplyTo(soap, &a->wsa__ReplyTo);
	soap_serialize_PointerTo_wsa__FaultTo(soap, &a->wsa__FaultTo);
	soap_serialize__wsa__To(soap, &a->wsa__To);
	soap_serialize__wsa__Action(soap, &a->wsa__Action);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xf890
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xf850
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0xf810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xf7d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xf7a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_getheader
SOAP_FMAC4 soap_getheader(struct soap *soap)
{
	soap->part = SOAP_IN_HEADER;
	soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
	soap->part = SOAP_END_HEADER;
	return soap->header == NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw $0x3, 0x1e5f0(%rax)
movq -0x8(%rbp), %rdi
leaq 0x349d8(%rip), %rsi     # 0x3850c
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x3b80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xbf30(%rax)
movq -0x8(%rbp), %rax
movw $0x4, 0x1e5f0(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xbf30(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_SOAP_ENV__Fault
SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize__QName(soap, &a->faultcode);
	soap_serialize_string(soap, &a->faultstring);
	soap_serialize_string(soap, &a->faultactor);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
	soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
	soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
	soap_serialize_string(soap, &a->SOAP_ENV__Node);
	soap_serialize_string(soap, &a->SOAP_ENV__Role);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x10740
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x10780
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x107c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0xf7a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x10740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_faultcode
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2)
		return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
	return (const char**)&soap->fault->faultcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40a0
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
cmpl $0x2, %eax
jne 0x4587
movq -0x10(%rbp), %rax
movq 0xbf38(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4596
movq -0x10(%rbp), %rax
movq 0xbf38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_faultstring
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2)
		return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
	return (const char**)&soap->fault->faultstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40a0
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
cmpl $0x2, %eax
jne 0x4687
movq -0x10(%rbp), %rax
movq 0xbf38(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x469a
movq -0x10(%rbp), %rax
movq 0xbf38(%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_getindependent
SOAP_FMAC4 soap_getindependent(struct soap *soap)
{
	int t;
	if (soap->version == 1)
	{	for (;;)
		{	if (!soap_getelement(soap, &t))
				if (soap->error || soap_ignore_element(soap))
					break;
		}
	}
	if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
		soap->error = SOAP_OK;
	return soap->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
cmpl $0x1, %eax
jne 0x4821
jmp 0x47eb
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x4860
cmpq $0x0, %rax
jne 0x481d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1f274(%rax)
jne 0x4819
movq -0x8(%rbp), %rdi
callq 0x5c80
cmpl $0x0, %eax
je 0x481b
jmp 0x481f
jmp 0x481d
jmp 0x47eb
jmp 0x4821
movq -0x8(%rbp), %rax
cmpl $0x6, 0x1f274(%rax)
je 0x483b
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x1f274(%rax)
jne 0x4849
movq -0x8(%rbp), %rax
movl $0x0, 0x1f274(%rax)
movq -0x8(%rbp), %rax
movl 0x1f274(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_ignore_element
SOAP_FMAC4 soap_ignore_element(struct soap *soap)
{
	if (!soap_peek_element(soap))
	{	int t;
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unexpected element '%s' in input (level=%u, %d)\n", soap->tag, soap->level, soap->body));
		if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
		{	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
			return soap->error = SOAP_TAG_MISMATCH;
		}
		if (!*soap->id || !soap_getelement(soap, &t))
		{	soap->peeked = 0;
			if (soap->fignore)
				soap->error = soap->fignore(soap, soap->tag);
			else
				soap->error = SOAP_OK;
			DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
			if (!soap->error && soap->body)
			{	soap->level++;
				while (!soap_ignore_element(soap))
					;
				if (soap->error == SOAP_NO_TAG)
					soap->error = soap_element_end_in(soap, NULL);
			}
		}
	}
	return soap->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19f40
cmpl $0x0, %eax
jne 0x5de5
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x5cbf
movq -0x10(%rbp), %rax
movswl 0x1e5f0(%rax), %eax
cmpl $0x3, %eax
jne 0x5cdf
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c998, %rsi          # imm = 0x1C998
leaq 0x32ad4(%rip), %rdx     # 0x387a9
callq 0x1d4c0
cmpl $0x0, %eax
jne 0x5cf9
movq -0x10(%rbp), %rax
movl $0x3, 0x1f274(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x5df2
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1cd98(%rax)
je 0x5d1d
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x4860
cmpq $0x0, %rax
jne 0x5de3
movq -0x10(%rbp), %rax
movw $0x0, 0x1e5f6(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc048(%rax)
je 0x5d62
movq -0x10(%rbp), %rax
movq 0xc048(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c998, %rsi          # imm = 0x1C998
callq *%rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1f274(%rax)
jmp 0x5d70
movq -0x10(%rbp), %rax
movl $0x0, 0x1f274(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1f274(%rax)
jne 0x5de1
movq -0x10(%rbp), %rax
movswl 0xc166(%rax), %eax
cmpl $0x0, %eax
je 0x5de1
movq -0x10(%rbp), %rax
movl 0xc168(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc168(%rax)
movq -0x10(%rbp), %rdi
callq 0x5c80
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5db7
jmp 0x5db9
jmp 0x5da0
movq -0x10(%rbp), %rax
cmpl $0x6, 0x1f274(%rax)
jne 0x5ddf
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b620
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1f274(%rax)
jmp 0x5de1
jmp 0x5de3
jmp 0x5de5
movq -0x10(%rbp), %rax
movl 0x1f274(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_in_PointerTounsignedInt
SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTounsignedInt(struct soap *soap, const char *tag, unsigned int **a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (unsigned int **)soap_malloc(soap, sizeof(unsigned int *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in_unsignedInt(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (unsigned int **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_unsignedInt, sizeof(unsigned int), 0);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b350
cmpl $0x0, %eax
je 0xae60
movq $0x0, -0x8(%rbp)
jmp 0xaf51
cmpq $0x0, -0x20(%rbp)
jne 0xae8e
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x19790
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xae8c
movq $0x0, -0x8(%rbp)
jmp 0xaf51
jmp 0xae8e
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpw $0x0, 0x1e5ec(%rax)
jne 0xaef1
movq -0x10(%rbp), %rax
movsbl 0x1d198(%rax), %eax
cmpl $0x23, %eax
je 0xaef1
movq -0x10(%rbp), %rdi
callq 0x2ad00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x5ea0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xaeef
movq $0x0, -0x8(%rbp)
jmp 0xaf51
jmp 0xaf49
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1d198, %rsi          # imm = 0x1D198
movq -0x20(%rbp), %rdx
movl $0x1b, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x25040
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movswl 0xc166(%rax), %eax
cmpl $0x0, %eax
je 0xaf47
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b620
cmpl $0x0, %eax
je 0xaf47
movq $0x0, -0x8(%rbp)
jmp 0xaf51
jmp 0xaf49
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_in_PointerTo_QName
SOAP_FMAC3 char *** SOAP_FMAC4 soap_in_PointerTo_QName(struct soap *soap, const char *tag, char ***a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (char ***)soap_malloc(soap, sizeof(char **))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in__QName(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (char ***)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__QName, sizeof(char *), 1);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b350
cmpl $0x0, %eax
je 0xb900
movq $0x0, -0x8(%rbp)
jmp 0xb9f4
cmpq $0x0, -0x20(%rbp)
jne 0xb92e
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x19790
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb92c
movq $0x0, -0x8(%rbp)
jmp 0xb9f4
jmp 0xb92e
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpw $0x0, 0x1e5ec(%rax)
jne 0xb991
movq -0x10(%rbp), %rax
movsbl 0x1d198(%rax), %eax
cmpl $0x23, %eax
je 0xb991
movq -0x10(%rbp), %rdi
callq 0x2ad00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xbc80
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb98f
movq $0x0, -0x8(%rbp)
jmp 0xb9f4
jmp 0xb9ec
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1d198, %rsi          # imm = 0x1D198
movq -0x20(%rbp), %rdx
movl $0x5, %ecx
movl $0x8, %r8d
movl $0x1, %r9d
callq 0x25040
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movswl 0xc166(%rax), %eax
cmpl $0x0, %eax
je 0xb9ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b620
cmpl $0x0, %eax
je 0xb9ea
movq $0x0, -0x8(%rbp)
jmp 0xb9f4
jmp 0xb9ec
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_putindependent
SOAP_FMAC4 soap_putindependent(struct soap *soap)
{
	int i;
	struct soap_plist *pp;
	if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
		for (i = 0; i < SOAP_PTRHASH; i++)
			for (pp = soap->pht[i]; pp; pp = pp->next)
				if (pp->mark1 == 2 || pp->mark2 == 2)
					if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
						return soap->error;
	return SOAP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
cmpl $0x1, %eax
jne 0xbe28
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xbe28
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x60000, %eax          # imm = 0x60000
cmpl $0x0, %eax
jne 0xbe28
movl $0x0, -0x14(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jge 0xbe26
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x3f20(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xbe16
movq -0x20(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x2, %eax
je 0xbdca
movq -0x20(%rbp), %rax
movsbl 0x21(%rax), %eax
cmpl $0x2, %eax
jne 0xbe07
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0x2c9c7(%rip), %rdx     # 0x387b3
callq 0xbe40
cmpl $0x0, %eax
je 0xbe05
movq -0x10(%rbp), %rax
movl 0x1f274(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xbe2f
jmp 0xbe07
jmp 0xbe09
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xbda9
jmp 0xbe18
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbd88
jmp 0xbe28
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)