LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: update
static
void
update (int idx)
{
    const int row = ROW(idx);
    const int col = COLUMN(idx);
    const int block = IDX_BLOCK(row, col);
    const int mask = DIGIT_STATE(DIGIT(idx));
    int i;

    board[idx] |= STATE_MASK;  /* filled - no choice possible */

    /* Digit cannot appear in row, column or block */
    for (i = 0; i < 9; ++i) {
        board[idx_row(row, i)] |= mask;
        board[idx_column(col, i)] |= mask;
        board[idx_block(block, i)] |= mask;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x9
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movl %edx, %esi
pushq $0x1b
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
leal (%rax,%rax,2), %ecx
movsbl %sil, %eax
movb $0x3, %dl
idivb %dl
movsbl %al, %ebx
addl %ecx, %ebx
movslq %edi, %r15
leaq 0xa09e(%rip), %r12      # 0xf4a0
movl (%r12,%r15,4), %eax
movl %eax, %ecx
shrl $0x10, %ecx
andb $0xf, %cl
pushq $0x40
popq %rbp
shll %cl, %ebp
orl $0xff80, %eax           # imm = 0xFF80
movl %eax, (%r12,%r15,4)
movslq %esi, %rax
leaq (%r12,%rax,4), %r13
shlq $0x2, %rax
shlq $0x2, %r15
subq %rax, %r15
xorl %r14d, %r14d
cmpq $0x9, %r14
je 0x545c
leaq (%r15,%r14,4), %rax
orl %ebp, (%r12,%rax)
orl %ebp, (%r13)
movl %ebx, %edi
movl %r14d, %esi
callq 0x27be
cltq
orl %ebp, (%r12,%rax,4)
incq %r14
addq $0x24, %r13
jmp 0x5431
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: move_to
static
void
move_to (int x, int y)
{
    curx = x;
    cury = y;

    move(TOP + 1 + y + y / 3,
         LEFT + 2 + 2 * (x + x / 3));

    wrefresh(stdscr);
}

// Assembly:
pushq %rbx
movl %edi, %ecx
movl %edi, 0xa578(%rip)      # 0xf9ec
movl %esi, 0xa576(%rip)      # 0xf9f0
movq 0x8b57(%rip), %rbx      # 0xdfd8
movq (%rbx), %rdi
pushq $0x3
popq %r8
movl %esi, %eax
xorl %edx, %edx
divl %r8d
addl %eax, %esi
addl $0x7, %esi
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
addl %ecx, %eax
leal 0x1d(,%rax,2), %edx
callq 0x22d0
movq (%rbx), %rdi
popq %rbx
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: tgets
static
char *
tgets (char *   str,
       int      n,
       FILE *    stream)
{
    char * ret = 0;
    if (stream == &default_template_file) {
        int i = 0;
        if (str != 0
            && n > 0
            && default_template_siz > default_template_pos
            && default_template_pos >= 0) {
            char ch = 0;
            while (default_template_pos < default_template_siz
                   && n > i) {
                unsigned char ci = default_template[default_template_pos >> 2];
                int j = (default_template_pos++ & 3);
                if (j > 0) {
                    ci >>= 2 * j;
                }
                ch = dtct[ci & 3];
                str[i++] = ch;
                if (ch == '\n') {
                    break;
                }
            }
            if (i < n) {
                str[i++] = 0;
                ret = str;
            } else if (i == n && 0 < n) {
                str[n - 1] = 0;
                ret = str;
            }
        }
    } else {
        ret = fgets (str,
                     n,
                     stream);
    }
    return ret;
}

// Assembly:
leaq 0xa3c7(%rip), %rax      # 0xfb98
cmpq %rax, %rdi
je 0x57e8
movq %rdi, %rdx
leaq 0xa220(%rip), %rdi      # 0xfa00
pushq $0x50
popq %rsi
jmp 0x21f0
movl 0xa486(%rip), %eax      # 0xfc74
cmpl $0x5dcc, %eax           # imm = 0x5DCC
setb %cl
andb 0xa474(%rip), %cl       # 0xfc70
cmpb $0x1, %cl
jne 0x5891
movl %eax, %esi
xorl %edx, %edx
leaq 0x29b0(%rip), %rdi      # 0x81c0
leaq 0x53ad(%rip), %r8       # 0xabc4
leaq 0xa1e2(%rip), %rax      # 0xfa00
leaq (%rsi,%rdx), %r9
cmpl $0x5dcb, %r9d           # imm = 0x5DCB
jg 0x5870
cmpq $0x4f, %rdx
ja 0x5870
movl %r9d, %ecx
shrl $0x2, %ecx
movzbl (%rcx,%rdi), %r10d
leal (%rsi,%rdx), %ecx
incl %ecx
movl %ecx, 0xa42d(%rip)      # 0xfc74
andl $0x3, %r9d
leal (%r9,%r9), %ecx
movl %r10d, %r11d
shrl %cl, %r11d
testl %r9d, %r9d
cmovel %r10d, %r11d
andl $0x3, %r11d
movb (%r11,%r8), %cl
movb %cl, (%rdx,%rax)
incq %rdx
cmpq $0x2, %r11
jne 0x581e
cmpl $0x4f, %edx
jg 0x5884
movslq %edx, %rcx
leaq 0xa181(%rip), %rax      # 0xfa00
movb $0x0, (%rcx,%rax)
retq
cmpl $0x50, %edx
jne 0x5891
movb $0x0, 0xa1bf(%rip)      # 0xfa4f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: fill
static
int
fill (int idx, int digit)
{
    assert(0 != digit);

    if (!IS_EMPTY(idx)) {
        return (DIGIT(idx) == digit) ? 0 : -1;
    }
    if (DISALLOWED(idx, digit)) {
        return -1;
    }

    board[idx] = SET_DIGIT(digit);
    update(idx);
    add_move(idx, digit, 0);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
je 0x58f8
movl %esi, %ebx
movslq %edi, %r14
leaq 0x9bf8(%rip), %rax      # 0xf4a0
movl (%rax,%r14,4), %ecx
movl %ecx, %edx
shrl $0x10, %edx
andl $0xf, %edx
je 0x58c2
xorl %ebp, %ebp
cmpl %ebx, %edx
setne %bpl
negl %ebp
jmp 0x58f1
leal 0x6(%rbx), %edx
movzbl %dl, %edx
btl %edx, %ecx
jae 0x58d2
pushq $-0x1
popq %rbp
jmp 0x58f1
movl %ebx, %ecx
shll $0x10, %ecx
movl %ecx, (%rax,%r14,4)
movl %r14d, %edi
callq 0x53cb
xorl %ebp, %ebp
movl %r14d, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x5917
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x43ae(%rip), %rdi      # 0x9cad
leaq 0x40a4(%rip), %rsi      # 0x99aa
leaq 0x43ab(%rip), %rcx      # 0x9cb8
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x2160
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: add_move
static
void
add_move (int idx, int digit, int choice)
{
    int i;

    if (sizeof(history) / sizeof(int) - 1 <= idx_history) {
        compress(81);
    }
    /* Never ignore the last move */
    history[idx_history++] = SET_INDEX(idx) | SET_DIGIT(digit) | choice;

    /* Ignore all previous references to idx */
    for (i = idx_history - 2; 0 <= i; --i) {
        if (GET_INDEX(history[i]) == idx) {
            history[i] |= IGNORED;
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %ebx
movl 0x9cec(%rip), %eax      # 0xf614
cmpl $0xf2, %eax
jb 0x593d
pushq $0x51
popq %rdi
callq 0x5980
movl 0x9cd7(%rip), %eax      # 0xf614
shll $0x10, %r14d
orl %ebx, %ebp
orl %r14d, %ebp
leal 0x1(%rax), %ecx
movl %ecx, 0x9cc5(%rip)      # 0xf614
movslq %eax, %rcx
leaq 0x9cc7(%rip), %rax      # 0xf620
movl %ebp, (%rax,%rcx,4)
movl %ecx, %ecx
testl %ecx, %ecx
jle 0x597b
movl -0x4(%rax,%rcx,4), %edx
decq %rcx
movl %edx, %esi
andl $0x7f, %esi
cmpl %ebx, %esi
jne 0x595e
orl $0x400000, %edx         # imm = 0x400000
movl %edx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: compress
static
void
compress(int limit)
{
    int i, j, k;
    /* Find the first ignored history item, if there is any. */
    for (k = 0; k < idx_history; ++k) {
        if (0 != (history[k] & IGNORED)) {
            break;
        }
    }
    /* Move the rest to compress the history */
    for (i = j = k; i < idx_history && j < limit; ++i) {
        if (!(history[i] & IGNORED)) {
            history[j++] = history[i];
        }
    }
    for (; i < idx_history; ++i) {
        history[j++] = history[i];
    }
    idx_history = j;
}

// Assembly:
movslq 0x9c8d(%rip), %rax      # 0xf614
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
leaq 0x9c86(%rip), %rsi      # 0xf620
cmpq %rdx, %rcx
je 0x59ae
testb $0x40, 0x2(%rsi)
jne 0x59b3
incq %rdx
addq $0x4, %rsi
jmp 0x599a
movq %rcx, %rdx
jmp 0x59b5
movl %edx, %ecx
leaq 0x9c64(%rip), %rsi      # 0xf620
leaq (%rsi,%rdx,4), %r8
movslq %ecx, %r9
cmpq %rax, %rdx
jge 0x59e5
cmpl %edi, %ecx
jge 0x59e5
movl (%r8), %r10d
btl $0x16, %r10d
jb 0x59dc
incl %ecx
movl %r10d, (%rsi,%r9,4)
incq %rdx
addq $0x4, %r8
jmp 0x59c0
shlq $0x2, %r9
xorl %edi, %edi
leaq (%rdx,%rdi), %r10
cmpq %rax, %r10
jge 0x5a08
movl (%r8), %r10d
leaq (%r9,%rdi,4), %r11
movl %r10d, (%rsi,%r11)
incq %rdi
addq $0x4, %r8
jmp 0x59eb
addl %edi, %ecx
movl %ecx, 0x9c04(%rip)      # 0xf614
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: backtrack
static
int
backtrack (void)
{
    int digit, idx;

    for (; 0 < --idx_history;) {
        if (history[idx_history] & CHOICE) {
            /* Remember the last choice, and advance */
            idx = GET_INDEX(history[idx_history]);
            digit = GET_DIGIT(history[idx_history]) + 1;
            reapply();
            if (-1 != choose(idx, digit)) {
                return idx;
            }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x98fd(%rip), %ecx      # 0xf614
pushq $-0x1
popq %r14
leaq 0x98fe(%rip), %r15      # 0xf620
movl %ecx, %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x98e7(%rip)      # 0xf614
cmpl $0x2, %eax
jl 0x5d66
movl %ecx, %eax
movl (%r15,%rax,4), %ebp
btl $0x15, %ebp
jae 0x5d22
movl %ebp, %ebx
andl $0x7f, %ebx
shrl $0x10, %ebp
andl $0xf, %ebp
incl %ebp
callq 0x29a1
movl %ebx, %edi
movl %ebp, %esi
callq 0x5e74
movl 0x98b5(%rip), %ecx      # 0xf614
cmpl $-0x1, %eax
je 0x5d22
jmp 0x5d69
movl %r14d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: classify
static
const char *
classify (void)
{
    int i, score;

    pass = 0;
    clear_moves();
    if (-1 == solve()) {
        return 0;
    }

    score = 81;
    for (i = 0; i < 81; ++i) {
        if (IS_FIXED(i)) {
            --score;
        }
    }
    assert(81 == idx_history);

    for (i = 0; i < 81; ++i) {
        if (history[i] & CHOICE) {
            score -= 5;
        }
    }
    return  class_name_by_score(score);
}

// Assembly:
pushq %rax
andl $0x0, 0x9e16(%rip)      # 0xfb94
callq 0x5e53
callq 0x5a11
cmpl $-0x1, %eax
je 0x5df7
pushq $0x51
popq %rax
xorl %ecx, %ecx
leaq 0x9707(%rip), %rdx      # 0xf4a0
cmpq $0x144, %rcx            # imm = 0x144
je 0x5db3
movl (%rcx,%rdx), %esi
shll $0xb, %esi
sarl $0x1f, %esi
addl %esi, %eax
addq $0x4, %rcx
jmp 0x5d99
cmpl $0x51, 0x985a(%rip)     # 0xf614
jne 0x5e34
xorl %ecx, %ecx
leaq 0x985b(%rip), %rdx      # 0xf620
cmpq $0x144, %rcx            # imm = 0x144
je 0x5de1
leal -0x5(%rax), %esi
testb $0x20, 0x2(%rcx,%rdx)
cmovel %eax, %esi
addq $0x4, %rcx
movl %esi, %eax
jmp 0x5dc5
movl 0x9dad(%rip), %ecx      # 0xfb94
imull $0xf, %ecx, %edx
cmpl %eax, %edx
jge 0x5dfb
leaq 0x3ed6(%rip), %rax      # 0x9ccb
jmp 0x5e32
xorl %eax, %eax
jmp 0x5e32
imull $0xb, %ecx, %edx
cmpl %eax, %edx
jge 0x5e0b
leaq 0x3ec7(%rip), %rax      # 0x9cd0
jmp 0x5e32
imull $0x7, %ecx, %edx
cmpl %eax, %edx
jge 0x5e1b
leaq 0x3ebc(%rip), %rax      # 0x9cd5
jmp 0x5e32
shll $0x2, %ecx
cmpl %eax, %ecx
leaq 0x3eb5(%rip), %rcx      # 0x9cdc
leaq 0x3eb3(%rip), %rax      # 0x9ce1
cmovlq %rcx, %rax
popq %rcx
retq
leaq 0x4350(%rip), %rdi      # 0xa18b
leaq 0x3b68(%rip), %rsi      # 0x99aa
leaq 0x4354(%rip), %rcx      # 0xa19d
movl $0x7df, %edx            # imm = 0x7DF
callq 0x2160
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: choose
static
int
choose (int idx, int digit)
{
    for (; digit <= 9; ++digit) {
        if (!DISALLOWED(idx, digit)) {
            board[idx] = SET_DIGIT(digit);
            update(idx);
            add_move(idx, digit, CHOICE);
            return digit;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl %edi, %eax
movl %esi, %edx
shll $0x10, %edx
pushq $-0x1
popq %rsi
leaq 0x9614(%rip), %rdi      # 0xf4a0
cmpl $0x9, %ebx
jg 0x5eaa
movl (%rdi,%rax,4), %r8d
movl %ebx, %ecx
shrl %cl, %r8d
testb $0x40, %r8b
je 0x5eae
incl %ebx
addl $0x10000, %edx          # imm = 0x10000
jmp 0x5e8c
movl %esi, %ebx
jmp 0x5ec6
movl %edx, (%rdi,%rax,4)
movl %ebp, %edi
callq 0x53cb
movl %ebp, %edi
movl %ebx, %esi
movl $0x200000, %edx         # imm = 0x200000
callq 0x5917
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: rotate
static
void
rotate (int * a, int len, int idx)
{
    int xdi = len - idx;
    int delta = idx - xdi;

    while (0 != delta && 0 != idx) {
        if (delta < 0) {
            if (1 == idx) {
                rotate1_left(a, len);
                idx = 0;
            } else {
                exchange(a, a + xdi, idx);
                len = xdi;
            }
        } else {
            /* 0 < delta */
            if (1 == xdi) {
                rotate1_right(a, len);
                idx = 0;
            } else {
                exchange(a, a + idx, xdi);
                a += xdi;
                len = idx;
                idx -= xdi;
            }
        }
        xdi = len - idx;
        delta = idx - xdi;
    }
    if (0 < idx) {
        exchange(a, a + idx, idx);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %r14d
subl %edx, %r14d
movl %edx, %eax
subl %r14d, %eax
pushq $0x1
popq %r15
testl %eax, %eax
je 0x5f98
testl %ebp, %ebp
je 0x5f98
movslq %r14d, %r12
movslq %esi, %rcx
testl %eax, %eax
js 0x5f33
cmpl $0x1, %r14d
jne 0x5f4e
leal -0x1(%rcx), %edx
movl -0x4(%rbx,%rcx,4), %eax
testl %edx, %edx
jle 0x5f6b
movl -0x4(%rbx,%rdx,4), %ecx
movl %ecx, (%rbx,%rdx,4)
decq %rdx
jmp 0x5f23
cmpl $0x1, %ebp
jne 0x5f6f
movl (%rbx), %eax
movq %r15, %rdx
cmpq %rcx, %rdx
jge 0x5f82
movl (%rbx,%rdx,4), %edi
movl %edi, -0x4(%rbx,%rdx,4)
incq %rdx
jmp 0x5f3d
movslq %ebp, %rax
leaq (%rbx,%rax,4), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x605b
leaq (%rbx,%r12,4), %rbx
movl %ebp, %esi
subl %r14d, %ebp
jmp 0x5f88
movl %eax, (%rbx)
jmp 0x5f86
leaq (%rbx,%r12,4), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x605b
movl %r14d, %esi
jmp 0x5f88
movl %eax, -0x4(%rbx,%rcx,4)
xorl %ebp, %ebp
movl %esi, %r14d
subl %ebp, %r14d
movl %ebp, %eax
subl %r14d, %eax
jmp 0x5efc
testl %ebp, %ebp
jle 0x5fb4
movl %ebp, %eax
leaq (%rbx,%rax,4), %rsi
movq %rbx, %rdi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x605b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: shuffle
static
void
shuffle (int * a, int len)
{
    int i, j, tmp;

    i = len;
    while (1 <= i) {
        j = rand() % i;
        tmp = a[--i];
        a[i] = a[j];
        a[j] = tmp;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
testl %r14d, %r14d
jle 0x5fed
callq 0x2380
cltd
idivl %r14d
movl -0x4(%rbx,%r14,4), %eax
movslq %edx, %rcx
movl (%rbx,%rcx,4), %edx
movl %edx, -0x4(%rbx,%r14,4)
decq %r14
movl %eax, (%rbx,%rcx,4)
jmp 0x5fc7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: write_title
static
void
write_title(const char * title)
{
    move(TITLE_LINE, LEFT_LEFT);
    wclrtoeol(stdscr);
    if (0 != title) {
        mvaddstr(TITLE_LINE,
                 (int)((LINE_SIZE - strlen(title)) / 2),
                 title);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x7fd4(%rip), %r15      # 0xdfd8
movq (%r15), %rdi
pushq $0x4
popq %rsi
xorl %edx, %edx
callq 0x22d0
movq (%r15), %rdi
callq 0x22e0
testq %rbx, %rbx
je 0x6055
movq (%r15), %r14
movq %rbx, %rdi
callq 0x2100
pushq $0x50
popq %rdx
subq %rax, %rdx
shrq %rdx
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x22d0
cmpl $-0x1, %eax
je 0x6055
movq (%r15), %rdi
pushq $-0x1
popq %rdx
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2360
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: exchange
static
void
exchange (int * a, int * b, int len)
{
    int i, tmp;
    for (i = 0; i < len; ++i) {
        tmp = a[i];
        a[i] = b[i];
        b[i] = tmp;
    }
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x607a
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %ecx, (%rsi,%rax,4)
incq %rax
jmp 0x6062
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x7f47(%rip), %rbx      # 0xdfd8
movq (%rbx), %rdi
pushq $0x14
popq %rsi
xorl %edx, %edx
callq 0x22d0
movq (%rbx), %rdi
callq 0x22e0
movl 0x9940(%rip), %edi      # 0xf9ec
movl 0x993e(%rip), %esi      # 0xf9f0
callq 0x546b
movb $0x0, 0x9936(%rip)      # 0xf9f4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: render
static
void
render (void)
{
    int i, x, y;

    for (i = 0; i < 81; ++i) {
        x = LEFT + 2 + 2 * (COLUMN(i) + COLUMN(i) / 3);
        y = TOP + 1 + ROW(i) + ROW(i) / 3;
        assert(0 <= DIGIT(i));
        assert(DIGIT(i) <= 9); /* XXX FAILING */
        if (IS_FIXED(i)) {
            attron(A_BOLD);
        }
        if (IS_EMPTY(i)) {
            mvaddch(y, x, '.');
        } else {
            mvaddch(y, x, '0' + DIGIT(i));
        }
        if (IS_FIXED(i)) {
            attroff(A_BOLD);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x93ce(%rip), %r13      # 0xf4a0
xorl %edx, %edx
movb $0x9, %sil
movzbl %dl, %eax
divb %sil
movl %eax, %r14d
movzbl %ah, %eax
movzbl %al, %eax
movb $0x3, %cl
divb %cl
cmpq $0x51, %rdx
je 0x61ef
movl %eax, %ebp
movzbl %dl, %ecx
movl %ecx, %eax
divb %sil
movl %eax, %r15d
movl %ecx, %eax
movb $0x1b, %cl
divb %cl
movl %eax, %r12d
movq %r13, %rbx
movl (%r13), %r13d
movl %r13d, %eax
andl $0xe0000, %eax          # imm = 0xE0000
cmpl $0xa0000, %eax          # imm = 0xA0000
jae 0x61fe
btl $0x14, %r13d
jae 0x614a
movq 0x7ea6(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl $0x200000, %esi         # imm = 0x200000
movq %rdx, %r13
xorl %edx, %edx
callq 0x21d0
movq %r13, %rdx
movl (%rbx), %r13d
movq %rdx, (%rsp)
addb %dl, %bpl
movzbl %r14b, %eax
leal (%rax,%rax,8), %eax
subb %al, %bpl
addb %bpl, %bpl
addb $0x1d, %bpl
movzbl %bpl, %edx
addb %r12b, %r15b
addb $0x7, %r15b
movzbl %r15b, %esi
movq 0x7e60(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
callq 0x22d0
testl $0xf0000, %r13d         # imm = 0xF0000
je 0x61a8
cmpl $-0x1, %eax
movq %rbx, %r13
je 0x61c2
movq 0x7e40(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movzwl 0x2(%r13), %esi
andl $0xf, %esi
orl $0x30, %esi
jmp 0x61bd
cmpl $-0x1, %eax
movq %rbx, %r13
je 0x61c2
movq 0x7e21(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
pushq $0x2e
popq %rsi
callq 0x2300
testb $0x10, 0x2(%r13)
je 0x61df
movq 0x7e08(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x2370
movq (%rsp), %rdx
incq %rdx
addq $0x4, %r13
jmp 0x60d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x45bf(%rip), %rdi      # 0xa7c4
leaq 0x379e(%rip), %rsi      # 0x99aa
leaq 0x459f(%rip), %rcx      # 0xa7b2
movl $0x73c, %edx            # imm = 0x73C
callq 0x2160
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl 0x97c3(%rip), %edi      # 0xf9ec
leaq 0x9270(%rip), %r14      # 0xf4a0
cmpl $0x7, %edi
jg 0x623f
incl %edi
movl 0x97b3(%rip), %esi      # 0xf9f0
jmp 0x624e
movl 0x97ab(%rip), %esi      # 0xf9f0
cmpl $0x7, %esi
jg 0x6255
incl %esi
xorl %edi, %edi
callq 0x546b
jmp 0x6264
xorl %edi, %edi
xorl %esi, %esi
callq 0x546b
testl %ebx, %ebx
jg 0x627b
incl %ebx
imull $0x9, 0x9785(%rip), %eax # 0xf9f0
movl 0x977b(%rip), %edi      # 0xf9ec
addl %edi, %eax
testb $0x10, 0x2(%r14,%rax,4)
jne 0x6230
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: getkey
static
int
getkey (void)
{
    int ch = wgetch(stdscr);
    if (0x1b == ch) {
        ch = wgetch(stdscr);
        if ('[' == ch) {
            ch = wgetch(stdscr);
            switch (ch) {
                case 'A': ch = VKEY_UP;     break;
                case 'B': ch = VKEY_DOWN;   break;
                case 'C': ch = VKEY_RIGHT;  break;
                case 'D': ch = VKEY_LEFT;   break;
                case 'H': ch = VKEY_HOME;   break;
                case '2': ch = VKEY_INSERT; break;
                case '3': ch = VKEY_DELETE; break;
                case '4': ch = VKEY_END;    break;
                case '5': ch = VKEY_PGUP;   break;
                case '6': ch = VKEY_PGDOWN; break;
                default:  ch = VKEY_IGNORE;
            }
            if (ch == VKEY_HOME ||
                ch == VKEY_DELETE ||
                ch == VKEY_INSERT ||
                ch == VKEY_END ||
                ch == VKEY_PGUP ||
                ch == VKEY_PGDOWN) {
                int ch4 = wgetch(stdscr);
                if (ch4 != '~') {
                    ch = VKEY_IGNORE;
                }
            }
        } else {
            /* Enabling the Esc Esc sequence to produce one Esc character */
            if (0x1b != ch) {
                ch = VKEY_IGNORE;
            }
        }
    }
    return ch;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x7d1e(%rip), %rbx      # 0xdfd8
movq (%rbx), %rdi
callq 0x20a0
cmpl $0x1b, %eax
jne 0x635e
movq (%rbx), %rdi
callq 0x20a0
cmpl $0x5b, %eax
jne 0x62ff
movq (%rbx), %rdi
callq 0x20a0
addl $-0x32, %eax
cmpl $0x16, %eax
ja 0x6331
leaq 0x1e6d(%rip), %rcx      # 0x815c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x132, %ebp            # imm = 0x132
jmp 0x634b
movl %eax, %ecx
cmpl $0x1b, %eax
movl $0x100, %eax            # imm = 0x100
cmovel %ecx, %eax
jmp 0x635e
movl $0x134, %ebp            # imm = 0x134
jmp 0x634b
movl $0x141, %eax            # imm = 0x141
jmp 0x635e
movl $0x133, %ebp            # imm = 0x133
jmp 0x634b
movl $0x142, %eax            # imm = 0x142
jmp 0x635e
movl $0x143, %eax            # imm = 0x143
jmp 0x635e
movl $0x100, %eax            # imm = 0x100
jmp 0x635e
movl $0x135, %ebp            # imm = 0x135
jmp 0x634b
movl $0x136, %ebp            # imm = 0x136
jmp 0x634b
movl $0x148, %ebp            # imm = 0x148
movq (%rbx), %rdi
callq 0x20a0
cmpl $0x7e, %eax
movl $0x100, %eax            # imm = 0x100
cmovel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x144, %eax            # imm = 0x144
jmp 0x635e
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x29a1
testl %eax, %eax
je 0x637b
pushq $-0x1
popq %rax
jmp 0x63e8
movl 0x9293(%rip), %edi      # 0xf614
callq 0x5980
movslq 0x9287(%rip), %rax      # 0xf614
leaq 0x928c(%rip), %rcx      # 0xf620
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x63a8
orb $0x10, 0x2(%rcx)
incq %rdx
addq $0x4, %rcx
jmp 0x6396
callq 0x29a1
callq 0x60c0
cmpl $0x50, 0x925b(%rip)     # 0xf614
movl 0x962d(%rip), %edi      # 0xf9ec
movl 0x962b(%rip), %esi      # 0xf9f0
jg 0x63da
leal (%rsi,%rsi,8), %eax
addl %edi, %eax
leaq 0x90cd(%rip), %rcx      # 0xf4a0
testb $0x10, 0x2(%rcx,%rax,4)
jne 0x63e1
callq 0x546b
jmp 0x63e6
callq 0x621d
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x20d0
movq %rbx, %rdi
callq 0x2eea
movl $0x1e8480, %edi         # imm = 0x1E8480
callq 0x23a0
popq %rbx
jmp 0x6089
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: get_filepath
static
void
get_filepath (char *            working_buffer,
              size_t            working_buffsize,
              const char *      default_name)
{
    char *          wbp = working_buffer;
    size_t          wbs = working_buffsize;
    const char *    dn  = default_name;
    /* Just for the sake of having shorter names. */
    assert (wbp != NULL && wbs > 0);
    if (wbp != NULL && wbs > 0) {

        if ('\0' == *wbp) {
            wbp[0] = '>';
            assert(dn != NULL && strlen(dn) < 6 + 3);
            if (0 == getcwd(wbp + 1,
                            (int)wbs - 1 - 1 - 6 - 3)) {
                /* The path is probably too long, use the filename alone. */
                strcpy(wbp + 1, dn);
            } else {
                if (dn != NULL) {
                    /* If the path would make it longer than the line length
                     * we can use just the filename. If the file name itself
                     * is too long, than we cannot avoid the wrap around, so
                     * it's better to be prepared for handling that.
                     */
                    if (strlen(wbp) + strlen(dn) > wbs) {
                        wbp[1] = '\0';
                    } else {
                        strcat(wbp, "/");
                    }
                    strcat(wbp, dn);
                }
            }
            wbp[wbs - 1] = '\0';
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x71d7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x71d7
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x71cd
movq %rdx, %r15
movb $0x3e, (%r14)
testq %rdx, %rdx
je 0x71f6
movq %r15, %rdi
callq 0x2100
cmpq $0x9, %rax
jae 0x71f6
leaq 0x1(%r14), %r12
leal -0xb(%rbx), %eax
movslq %eax, %rsi
movq %r12, %rdi
callq 0x21a0
testq %rax, %rax
je 0x71a0
movq %r14, %rdi
callq 0x2100
movq %rax, %r13
movq %r15, %rdi
callq 0x2100
addq %r13, %rax
cmpq %rbx, %rax
jbe 0x71ad
movb $0x0, (%r12)
jmp 0x71bc
movq %r12, %rdi
movq %r15, %rsi
callq 0x2050
jmp 0x71c7
movq %r14, %rdi
callq 0x2100
movw $0x2f, (%r14,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2310
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x387a(%rip), %rdi      # 0xaa58
leaq 0x27c5(%rip), %rsi      # 0x99aa
leaq 0x3883(%rip), %rcx      # 0xaa6f
movl $0xc5c, %edx            # imm = 0xC5C
callq 0x2160
leaq 0x38a2(%rip), %rdi      # 0xaa9f
leaq 0x27a6(%rip), %rsi      # 0x99aa
leaq 0x3864(%rip), %rcx      # 0xaa6f
movl $0xc61, %edx            # imm = 0xC61
callq 0x2160
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl 0x40(%rdi), %eax
cmpl %eax, 0x3c(%rdi)
jg 0x7231
movq %rdi, %rbx
movslq 0x24(%rdi), %rdx
cmpl %eax, %edx
jl 0x7231
cmpl 0x20(%rbx), %edx
jle 0x723d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movl 0x38(%rbx), %ecx
addl %eax, %ecx
cmpl %ecx, %edx
jge 0x727c
movq 0x6d8b(%rip), %r14      # 0xdfd8
movq (%r14), %rdi
movl 0x1c(%rbx), %esi
subl %eax, %edx
addl 0x2c(%rbx), %edx
callq 0x22d0
cmpl $-0x1, %eax
je 0x7289
movq (%r14), %rdi
movq (%rbx), %rax
movslq 0x24(%rbx), %rcx
movsbl (%rax,%rcx), %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2300
cmpl %ecx, %edx
jne 0x7231
movq (%rbx), %rax
cmpb $0x0, (%rax,%rdx)
jne 0x7231
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x50(%rdi)
je 0x7298
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6d32(%rip), %r14      # 0xdfd8
movq (%r14), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x7215
movq (%r14), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2370
// File: /workspace/github_c_makefile_star2_O2/cinemast[P]sudoku/sudoku.c
// Function: el_adjust_markers
static
void
el_adjust_markers (edit_t *   ep)
{
    int first_invisible = ep->m_1 + ep->x_mv;
    if (ep->m_0 == ep->m_1) {
        /* The first visible is the first editable character. */
        if (ep->prompt != ep->dprompt) {
            /* Show the default prompt if it is not shown yet. */
            ep->prompt = ep->dprompt;
            mvaddch(ep->efy, ep->x_0, ep->prompt);
        }
    } else {
        /* The first visible is not the first editable character. */
        if (ep->prompt != '<') {
            ep->prompt = '<';
            /* Show the '<' prompt. */
            mvaddch(ep->efy, ep->x_0, ep->prompt);
        }
    }
    if (ep->ecn > first_invisible) {
        /* The last visible is not the last editable character. */
        if (ep->eol_mark != '<') {
            ep->eol_mark = '<';
            mvaddch(ep->efy, ep->x_3, ep->eol_mark);
        }
    } else {
        if (ep->eol_mark != ' ') {
            ep->eol_mark = ' ';
            mvaddch(ep->efy, ep->x_3, ep->eol_mark);
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
movl 0x38(%rdi), %ebp
addl %ecx, %ebp
movl 0x44(%rdi), %eax
cmpl %ecx, 0x3c(%rdi)
jne 0x72f5
movl 0x48(%rbx), %ecx
cmpl %ecx, %eax
je 0x732d
movl %ecx, 0x44(%rbx)
jmp 0x7301
cmpl $0x3c, %eax
je 0x732d
movl $0x3c, 0x44(%rbx)
movq 0x6cd0(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x1c(%rbx), %esi
movl 0x28(%rbx), %edx
callq 0x22d0
cmpl $-0x1, %eax
je 0x732d
movq 0x6cb6(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x44(%rbx), %esi
callq 0x2300
movl 0x4c(%rbx), %eax
cmpl %ebp, 0x20(%rbx)
jle 0x7343
cmpl $0x3c, %eax
je 0x7381
movl $0x3c, 0x4c(%rbx)
jmp 0x734f
cmpl $0x20, %eax
je 0x7381
movl $0x20, 0x4c(%rbx)
movq 0x6c82(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x1c(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0x22d0
cmpl $-0x1, %eax
je 0x7381
movq 0x6c68(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x4c(%rbx), %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2300
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x73c2
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x73bc
movsbl (%rbx), %esi
movq %rdx, %rdi
callq 0x2120
testq %rax, %rax
je 0x73bc
incq %rbx
decq %r14
jmp 0x73bc
cmpb $0x20, (%rbx)
jne 0x73c4
incq %rbx
subq $0x1, %r14
jae 0x73b4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0xdbd(%rip), %rdi       # 0x2004
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0x10f0
cmpl $-0x1, %eax
je 0x12bc
movl %eax, %ebx
pushq $0x3
popq %rdx
pushq $0x11
popq %rcx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x64000000, %r9d       # imm = 0x64000000
movl %eax, %r8d
callq 0x1080
cmpq $-0x1, %rax
je 0x12c5
movq %rax, %r14
movq %rax, %rdi
callq 0x1aa2
leaq 0xed9(%rip), %rdi       # 0x2169
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
movl $0x400000, %esi         # imm = 0x400000
movq %r14, %rdi
callq 0x10e0
cmpl $-0x1, %eax
je 0x12ce
movl %ebx, %edi
callq 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd92(%rip), %rdi       # 0x2055
jmp 0x12d5
leaq 0xd65(%rip), %rdi       # 0x2031
jmp 0x12d5
leaq 0xd38(%rip), %rdi       # 0x200d
callq 0x1060
xorl %edi, %edi
callq 0x1120
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb0f0
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xb194
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xb161
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xb12e
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xb0fb
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xb0f0
addq $0x30, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb0f0
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_SOAP_ENV__Header
SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Header *a, const char *type)
{
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
		return soap->error;
	if (soap_out__wsa__MessageID(soap, "wsa:MessageID", -1, &a->wsa__MessageID, ""))
		return soap->error;
	if (soap_out_PointerTo_wsa__RelatesTo(soap, "wsa:RelatesTo", -1, &a->wsa__RelatesTo, ""))
		return soap->error;
	if (soap_out_PointerTo_wsa__From(soap, "wsa:From", -1, &a->wsa__From, ""))
		return soap->error;
	soap->mustUnderstand = 1;
	if (soap_out_PointerTo_wsa__ReplyTo(soap, "wsa:ReplyTo", -1, &a->wsa__ReplyTo, ""))
		return soap->error;
	soap->mustUnderstand = 1;
	if (soap_out_PointerTo_wsa__FaultTo(soap, "wsa:FaultTo", -1, &a->wsa__FaultTo, ""))
		return soap->error;
	soap->mustUnderstand = 1;
	if (soap_out__wsa__To(soap, "wsa:To", -1, &a->wsa__To, ""))
		return soap->error;
	soap->mustUnderstand = 1;
	if (soap_out__wsa__Action(soap, "wsa:Action", -1, &a->wsa__Action, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1d
popq %rcx
movl %edx, %esi
movq %r15, %rdx
callq 0x169d2
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x16e14
testl %eax, %eax
jne 0x38bc
leaq 0x1f009(%rip), %rsi     # 0x227af
leaq 0x1fe41(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0xa980
testl %eax, %eax
jne 0x38bc
leaq 0x8(%r15), %rcx
leaq 0x1ef87(%rip), %rsi     # 0x22755
leaq 0x1fe19(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xaaa6
testl %eax, %eax
jne 0x38bc
leaq 0x10(%r15), %rcx
leaq 0x1ef59(%rip), %rsi     # 0x2274c
leaq 0x1fdf4(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xaa47
testl %eax, %eax
jne 0x38bc
movw $0x1, 0x1e5ea(%rbx)
leaq 0x18(%r15), %rcx
leaq 0x1ef1f(%rip), %rsi     # 0x22740
leaq 0x1fdc6(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xa9e8
testl %eax, %eax
jne 0x38bc
movw $0x1, 0x1e5ea(%rbx)
leaq 0x20(%r15), %rcx
leaq 0x1eee5(%rip), %rsi     # 0x22734
leaq 0x1fd98(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xa989
testl %eax, %eax
jne 0x38bc
movw $0x1, 0x1e5ea(%rbx)
leaq 0x28(%r15), %rcx
leaq 0x1ef2f(%rip), %rsi     # 0x227a8
leaq 0x1fd6e(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xa980
testl %eax, %eax
jne 0x38bc
movw $0x1, 0x1e5ea(%rbx)
addq $0x30, %r15
leaq 0x1eefa(%rip), %rsi     # 0x2279d
leaq 0x1fd44(%rip), %r8      # 0x235ee
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0xa980
testl %eax, %eax
je 0x38ce
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x16e91
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movw $0x3, 0x1e5f0(%rdi)
leaq 0x1ec28(%rip), %rsi     # 0x22520
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x391d
movq %rax, 0xbf30(%rbx)
movw $0x4, 0x1e5f0(%rbx)
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb0f0
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xb0f0
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xb0f0
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xba36
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xba69
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xba9c
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0xb0f0
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xb0f0
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba36
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x3da0
cmpw $0x2, 0x2(%rbx)
movq 0xbf38(%rbx), %rax
jne 0x406a
movq 0x28(%rax), %rax
jmp 0x406e
addq $0x8, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x1, 0x2(%rdi)
jne 0x4130
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4151
testq %rax, %rax
jne 0x410b
cmpl $0x0, 0x1f274(%rbx)
jne 0x4130
movq %rbx, %rdi
callq 0x4e5c
testl %eax, %eax
je 0x410b
movl 0x1f274(%rbx), %eax
cmpl $0x6, %eax
je 0x4140
cmpl $-0x1, %eax
jne 0x4149
andl $0x0, 0x1f274(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11343
testl %eax, %eax
je 0x4e7a
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x10, 0x5(%rbx)
je 0x4e8a
cmpw $0x3, 0x1e5f0(%rbx)
jne 0x4ef1
leaq 0x1c998(%rbx), %r14
leaq 0x1d925(%rip), %rdx     # 0x227bd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13169
testl %eax, %eax
je 0x4ef1
cmpb $0x0, 0x1cd98(%rbx)
je 0x4ec2
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x4151
testq %rax, %rax
jne 0x4e6c
andw $0x0, 0x1e5f6(%rbx)
movq 0xc048(%rbx), %rax
testq %rax, %rax
je 0x4f03
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
movl %eax, 0x1f274(%rbx)
testl %eax, %eax
jne 0x4e6c
leaq 0x1f274(%rbx), %r14
jmp 0x4f11
movl $0x3, 0x1f274(%rbx)
pushq $0x3
popq %rax
jmp 0x4e72
leaq 0x1f274(%rbx), %r14
andl $0x0, 0x1f274(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x4e6c
incl 0xc168(%rbx)
movq %rbx, %rdi
callq 0x4e5c
testl %eax, %eax
je 0x4f25
cmpl $0x6, (%r14)
jne 0x4e6c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12190
movl %eax, 0x1f274(%rbx)
jmp 0x4e6c
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x11fde
testl %eax, %eax
jne 0x86be
testq %rbx, %rbx
jne 0x8643
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x10ebe
movq %rax, %rbx
testq %rax, %rax
je 0x8695
andq $0x0, (%rbx)
cmpw $0x0, 0x1e5ec(%r15)
jne 0x865c
cmpb $0x23, 0x1d198(%r15)
jne 0x869a
leaq 0x1d198(%r15), %rsi
pushq $0x1b
popq %rcx
pushq $0x4
popq %r8
movq %r15, %rdi
movq %rbx, %rdx
xorl %r9d, %r9d
callq 0x1730d
movq %rax, %rbx
cmpw $0x0, 0xc166(%r15)
je 0x86bb
movq %r15, %rdi
movq %r14, %rsi
callq 0x12190
testl %eax, %eax
je 0x86bb
xorl %r13d, %r13d
jmp 0x86be
movq %r15, %rdi
callq 0x1a4da
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x4f62
movq %rax, (%rbx)
testq %rax, %rax
je 0x8695
movq %rbx, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x11fde
testl %eax, %eax
jne 0x8cae
testq %rbx, %rbx
jne 0x8c32
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x10ebe
movq %rax, %rbx
testq %rax, %rax
je 0x8c85
andq $0x0, (%rbx)
cmpw $0x0, 0x1e5ec(%r15)
jne 0x8c4b
cmpb $0x23, 0x1d198(%r15)
jne 0x8c8a
leaq 0x1d198(%r15), %rsi
pushq $0x5
popq %rcx
pushq $0x8
popq %r8
pushq $0x1
popq %r9
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1730d
movq %rax, %rbx
cmpw $0x0, 0xc166(%r15)
je 0x8cab
movq %r15, %rdi
movq %r14, %rsi
callq 0x12190
testl %eax, %eax
je 0x8cab
xorl %r13d, %r13d
jmp 0x8cae
movq %r15, %rdi
callq 0x1a4da
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x8e4f
movq %rax, (%rbx)
testq %rax, %rax
je 0x8c85
movq %rbx, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq