LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_create_multi_ex
vm_ast_t *vm_ast_create_multi_ex(unsigned short kind_type,
                                 const void *ast_value, ...) {
  va_list ap;
  vm_ast_t *ret;

  va_start(ap, ast_value);
  ret = vm_ast_create_from_va_list(kind_type, ast_value, ap);
  va_end(ap);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x1406
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r10, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x20(%rbp)
callq 0x134c
movl -0x20(%rbp), %edx
cmpq $0x28, %rdx
ja 0x143d
movq %rdx, %rcx
addq -0x10(%rbp), %rcx
addl $0x8, %edx
movl %edx, -0x20(%rbp)
jmp 0x1449
movq -0x18(%rbp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x18(%rbp)
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x145b
movq %rax, %rdi
callq 0x1464
jmp 0x1425
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_add_child
vm_ast_t *vm_ast_add_child(vm_ast_t *ast, vm_ast_t *child) {
  if (ast->num_childs >= ast->num_childs_alloc_size) {
    ast =
        vm_ast_realloc(ast, vm_ast_calculate_child(ast->num_childs_alloc_size),
                       vm_ast_calculate_child(ast->num_childs_alloc_size + 4));

    ast->num_childs_alloc_size += 4;
  }

  ast->childs[ast->num_childs++] = child;
  return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
jb 0x14b6
leaq 0x30(,%rcx,8), %r14
leaq 0x50(,%rcx,8), %rsi
cmpq %r14, %rsi
jbe 0x14cb
callq 0x1130
testq %rax, %rax
je 0x14ea
movq %rax, %rdi
imulq $0x38, %r14, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi,%rax)
movups %xmm0, (%rdi,%rax)
addq $0x4, 0x28(%rdi)
movq 0x20(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movq %rbx, 0x30(%rdi,%rax,8)
movq %rdi, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3b67(%rip), %rdi      # 0x5039
leaq 0x3b37(%rip), %rsi      # 0x5010
leaq 0x3b6d(%rip), %rcx      # 0x504d
movl $0x13, %edx
callq 0x10b0
leaq 0x3b13(%rip), %rdi      # 0x5004
leaq 0x3b18(%rip), %rsi      # 0x5010
leaq 0x3b4e(%rip), %rcx      # 0x504d
movl $0x15, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_dtor
void vm_ast_dtor(vm_ast_t *ast) {
  if (ast == NULL) {
    return;
  }

  for (int i = 0; i < ast->num_childs; i++) {
    vm_ast_dtor(ast->childs[i]);
  }

  free(ast);
}

// Assembly:
testq %rdi, %rdi
je 0x2a8d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x2a81
xorl %r14d, %r14d
movq 0x30(%rbx,%r14,8), %rdi
callq 0x2a55
incq %r14
cmpq %r14, 0x20(%rbx)
ja 0x2a6e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: DumpString
void DumpString(int level, const void *b, size_t size, const char *prefix_string)
{
    size_t i;
    const char * s = (const char*) b;
    unsigned char c;

    DebugPrintf(level, prefix_string);

    DebugPrintf(level, "'");
    for (i = 0; i < size; i++)
    {
        c = s[i];
        if (c >= 0x20 && c <= 0x7e) /*isprint?*/
        {
            DebugPrintf(level, "%c", c);
        }
        else
        {
            DebugPrintf(level, "(%02X)", c);
        }
    }
    DebugPrintf(level, "'\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movq %rcx, %rsi
xorl %eax, %eax
callq 0x43fd
leaq 0x4b70(%rip), %rsi      # 0x909b
movl %ebx, %edi
xorl %eax, %eax
callq 0x43fd
testq %r14, %r14
je 0x456c
leaq 0x4b5d(%rip), %r12      # 0x909d
leaq 0x4b59(%rip), %r13      # 0x90a0
xorl %ebp, %ebp
movzbl (%r15,%rbp), %edx
leal -0x20(%rdx), %eax
movq %r12, %rsi
cmpb $0x5f, %al
jb 0x455b
movq %r13, %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x43fd
incq %rbp
cmpq %rbp, %r14
jne 0x4549
leaq 0x619c(%rip), %rsi      # 0xa70f
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43fd
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: PrepareKeyboardTtySettings
void PrepareKeyboardTtySettings(void)
{
#if defined COMPILE_FOR_LINUX || defined COMPILE_FOR_CYGWIN
    /* store the current tty settings */
    if (!tcgetattr(0, &keyboard_origtty))
    {
        struct termios tty;
        /* start with the current settings */
        tty = keyboard_origtty;
        /* make modifications to put it in raw mode, turn off echo */
        tty.c_lflag &= ~ICANON;
        tty.c_lflag &= ~ECHO;
        tty.c_lflag &= ~ISIG;
        tty.c_cc[VMIN] = 1;
        tty.c_cc[VTIME] = 0;

        /* put the settings into effect */
        tcsetattr(0, TCSADRAIN, &tty);
    }
#endif
}

// Assembly:
subq $0x48, %rsp
leaq 0xcab0(%rip), %rsi      # 0x11100
xorl %edi, %edi
callq 0x41d0
testl %eax, %eax
jne 0x469f
movups 0xca9e(%rip), %xmm0     # 0x11100
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movups 0xcaa1(%rip), %xmm0     # 0x11110
movaps %xmm0, 0x10(%rdx)
movups 0xcab2(%rip), %xmm0     # 0x1112c
movups %xmm0, 0x2c(%rdx)
movups 0xca9b(%rip), %xmm0     # 0x11120
movaps %xmm0, 0x20(%rdx)
andb $-0xc, 0xc(%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %edi, %edi
movl $0x1, %esi
callq 0x41e0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: ReceiveComPortBlockComplete
int ReceiveComPortBlockComplete(ISP_ENVIRONMENT *IspEnvironment,
                                                    void *block, size_t size, unsigned timeout)
{
    unsigned long realsize = 0, read;
    char *result;
    char tmp_string[32];

    result = (char*) block;

    SerialTimeoutSet(IspEnvironment, timeout);

    do
    {
        ReceiveComPortBlock(IspEnvironment, result + realsize, size - realsize, &read);

        realsize += read;

    } while ((realsize < size) && (SerialTimeoutCheck(IspEnvironment) == 0));

    sprintf(tmp_string, "Answer(Length=%ld): ", realsize);
    DumpString(3, result, realsize, tmp_string);

    if (realsize != size)
    {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl %ecx, %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
movl %eax, 0xfc(%rdi)
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
leaq (%r14,%r15), %rsi
movq %rbx, %rdx
subq %r15, %rdx
movq %r12, %rdi
movq %r13, %rcx
callq 0x48ac
addq 0x8(%rsp), %r15
cmpq %rbx, %r15
jae 0x4a14
cmpl $0x0, 0xfc(%r12)
jne 0x49ea
leaq 0x4654(%rip), %rsi      # 0x906f
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4230
movl $0x3, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x4507
xorl %eax, %eax
cmpq %rbx, %r15
setne %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: LoadFiles1
static int LoadFiles1(ISP_ENVIRONMENT *IspEnvironment, const FILE_LIST *file)
{
    int ret_val;

    if( file->prev != 0)
    {
        DebugPrintf( 3, "Follow file list %s\n", file->name);

        ret_val = LoadFiles1( IspEnvironment, file->prev);
    if( ret_val != 0)
    {
      return ret_val;
    }
    }

    DebugPrintf( 3, "Attempt to read File %s\n", file->name);
    if(file->hex_flag != 0)
    {
        ret_val = LoadFile(IspEnvironment, file->name, FORMAT_HEX);
    }
    else
    {
    ret_val = LoadFile(IspEnvironment, file->name, FORMAT_BINARY);
    }
    if( ret_val != 0)
    {
    return ret_val;
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x55be
movq (%r14), %rdx
leaq 0x3c0b(%rip), %rsi      # 0x91a5
movl $0x3, %edi
xorl %eax, %eax
callq 0x43fd
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x557f
testl %eax, %eax
je 0x55be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdx
leaq 0x3bf2(%rip), %rsi      # 0x91ba
movl $0x3, %edi
xorl %eax, %eax
callq 0x43fd
xorl %edx, %edx
cmpb $0x0, 0x10(%r14)
setne %dl
movq (%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55ed
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: Ascii2Hex
static unsigned char Ascii2Hex(unsigned char c)
{
    if (c >= '0' && c <= '9')
    {
        return (unsigned char)(c - '0');
    }

    if (c >= 'A' && c <= 'F')
    {
        return (unsigned char)(c - 'A' + 10);
    }

    if (c >= 'a' && c <= 'f')
    {
        return (unsigned char)(c - 'a' + 10);
    }

    DebugPrintf(1, "Wrong Hex-Nibble %c (%02X)\n", c, c);
    exit(1);

    return 0;  // this "return" will never be reached, but some compilers give a warning if it is not present
}

// Assembly:
leal -0x30(%rdi), %eax
cmpb $0xa, %al
jb 0x5c24
leal -0x41(%rdi), %eax
cmpb $0x5, %al
ja 0x5c17
addb $-0x37, %dil
jmp 0x5c22
leal -0x61(%rdi), %eax
cmpb $0x5, %al
ja 0x5c25
addb $-0x57, %dil
movl %edi, %eax
retq
pushq %rax
movzbl %dil, %ecx
leaq 0x37c0(%rip), %rsi      # 0x93f1
movl $0x1, %edi
movl %ecx, %edx
xorl %eax, %eax
callq 0x43fd
movl $0x1, %edi
callq 0x4240
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: AddFileHex
static int AddFileHex(ISP_ENVIRONMENT *IspEnvironment, const char *arg)
{
    FILE_LIST *entry;

    // Add file to list.  If cannot allocate storage for node return an error.
    entry = malloc(sizeof(FILE_LIST));
    if( entry == 0)
    {
        DebugPrintf(1, "Error %d Could not allocated memory for file node %s\n", ERR_ALLOC_FILE_LIST, arg);
        return  ERR_ALLOC_FILE_LIST;
    }

    // Build up entry and insert it at the start of the list.
    entry->name = arg;
    entry->prev = IspEnvironment->f_list;
    entry->hex_flag = 1;
    IspEnvironment->f_list = entry;

    return 0;       // Success.
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x4160
testq %rax, %rax
je 0x5c79
movq %rbx, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x10(%rax)
movq %rax, 0x10(%r14)
xorl %ebp, %ebp
jmp 0x5c99
leaq 0x4355(%rip), %rsi      # 0x9fd5
movl $0x3c, %ebp
movl $0x1, %edi
movl $0x3c, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x43fd
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpc21isp.c
// Function: AddFileBinary
static int AddFileBinary(ISP_ENVIRONMENT *IspEnvironment, const char *arg)
{
    FILE_LIST *entry;

    // Add file to list. If cannot allocate storage for node return an error.
    entry = malloc(sizeof(FILE_LIST));
    if( entry == 0)
    {
        DebugPrintf( 1, "Error %d Could not allocated memory for file node %s\n", ERR_ALLOC_FILE_LIST, arg);
        return  ERR_ALLOC_FILE_LIST;
    }

    // Build up entry and insert it at the start of the list.
    entry->name = arg;
    entry->prev = IspEnvironment->f_list;
    entry->hex_flag = 0;
    IspEnvironment->f_list = entry;

    return 0;       // Success.
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x4160
testq %rax, %rax
je 0x5cd0
movq %rbx, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, 0x10(%r14)
xorl %ebp, %ebp
jmp 0x5cf0
leaq 0x42fe(%rip), %rsi      # 0x9fd5
movl $0x3c, %ebp
movl $0x1, %edi
movl $0x3c, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x43fd
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/adprog.c
// Function: AnalogDevicesDownload
int AnalogDevicesDownload(ISP_ENVIRONMENT *IspEnvironment)
{
    AnalogDevicesSync(IspEnvironment);
    AnalogDevicesErase(IspEnvironment);
    if (IspEnvironment->BinaryLength > 0x80000)
    {
        DebugPrintf(2, "Note:  Flash remapped 0x80000 to 0.\n");
        AnalogDevicesWrite(IspEnvironment, IspEnvironment->BinaryContent + 0x80000, 0, IspEnvironment->BinaryLength-0x80000);
    }
    else
    {
        AnalogDevicesWrite(IspEnvironment, IspEnvironment->BinaryContent, 0, IspEnvironment->BinaryLength);
    }
    return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x46b7
leaq 0x4318(%rip), %rsi      # 0xa030
movl $0x2, %edi
xorl %eax, %eax
callq 0x43fd
leaq 0x3(%rsp), %r14
movb $0x8, (%r14)
movl $0x5, %ebp
leaq 0x4(%rsp), %r15
leaq 0x4306(%rip), %r12      # 0xa044
leaq 0x4324(%rip), %r13      # 0xa069
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44ba
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1f4, %ecx            # imm = 0x1F4
callq 0x49b9
testl %eax, %eax
je 0x5d7f
movl $0x3, %edi
movq %r13, %rsi
xorl %eax, %eax
callq 0x43fd
jmp 0x5d9e
cmpl $0x43754441, 0x4(%rsp)  # imm = 0x43754441
je 0x5dc7
movl $0x18, %edx
movl $0x3, %edi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4507
movq %rbx, %rdi
callq 0x46b7
decl %ebp
jne 0x5d45
leaq 0x42e3(%rip), %rsi      # 0xa094
movl $0x1, %edi
xorl %eax, %eax
callq 0x43fd
movl $0x4, %edi
callq 0x4240
leaq 0x42f3(%rip), %rsi      # 0xa0c1
movl $0x2, %edi
xorl %eax, %eax
callq 0x43fd
leaq 0x4(%rsp), %rsi
movq $0x45060e07, (%rsi)     # imm = 0x45060E07
movw $0xb500, 0x8(%rsi)      # imm = 0xB500
movq %rbx, %rdi
callq 0x5fdc
leaq 0x42d2(%rip), %rsi      # 0xa0cd
movl $0x2, %edi
xorl %eax, %eax
callq 0x43fd
movq 0x60(%rbx), %rdx
cmpq $0x80001, %rdx          # imm = 0x80001
jb 0x5e3d
leaq 0x41f0(%rip), %rsi      # 0xa00b
movl $0x2, %edi
xorl %eax, %eax
callq 0x43fd
movl $0x80000, %esi          # imm = 0x80000
addq 0x58(%rbx), %rsi
movq $-0x80000, %rdx         # imm = 0xFFF80000
addq 0x60(%rbx), %rdx
jmp 0x5e41
movq 0x58(%rbx), %rsi
movq %rbx, %rdi
callq 0x5e5d
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/adprog.c
// Function: AnalogDevicesWrite
static void AnalogDevicesWrite(ISP_ENVIRONMENT *IspEnvironment,
                                         const void *data, long address, size_t bytes)
{
    AD_PACKET packet;
    const BINARY *prog_data;

    DebugPrintf(2, "Writing %d bytes ", bytes);
    prog_data = (const BINARY*) data;
    while (bytes > AD_PACKET_SIZE)
    {
        AnalogDevicesFormPacket(IspEnvironment, 'W', AD_PACKET_SIZE, address, prog_data, &packet);
        AnalogDevicesSendPacket(IspEnvironment, &packet);
        address += AD_PACKET_SIZE;
        prog_data += AD_PACKET_SIZE;
        bytes -= AD_PACKET_SIZE;
        DebugPrintf(2, ".");
    }
    if (bytes > 0)
    {
        AnalogDevicesFormPacket(IspEnvironment, 'W', bytes, address, prog_data, &packet);
        AnalogDevicesSendPacket(IspEnvironment, &packet);
        DebugPrintf(2, ".");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4314(%rip), %rsi      # 0xa192
xorl %r12d, %r12d
movl $0x2, %edi
xorl %eax, %eax
callq 0x43fd
cmpq $0xfb, %r15
jb 0x5eee
leaq 0x5(%rsp), %r13
movl $0xfa, %ebp
xorl %r12d, %r12d
leaq (%r14,%r12), %rcx
movl $0x57, %edi
movl $0xfa, %esi
movl %r12d, %edx
movq %r13, %r8
callq 0x5f3e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5fdc
addq %rbp, %r12
addq $-0xfa, %r15
movl $0x2, %edi
leaq 0x4cf9(%rip), %rsi      # 0xabd6
xorl %eax, %eax
callq 0x43fd
cmpq %rbp, %r15
ja 0x5ea3
addq %r12, %r14
jmp 0x5ef3
testq %r15, %r15
je 0x5f2c
leaq 0x5(%rsp), %r13
movl $0x57, %edi
movl %r15d, %esi
movl %r12d, %edx
movq %r14, %rcx
movq %r13, %r8
callq 0x5f3e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5fdc
leaq 0x4cb6(%rip), %rsi      # 0xabd6
movl $0x2, %edi
xorl %eax, %eax
callq 0x43fd
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/adprog.c
// Function: AnalogDevicesSendPacket
static void AnalogDevicesSendPacket(ISP_ENVIRONMENT *IspEnvironment,
                                                const AD_PACKET * packet)
{
    BINARY response;
    int retry = 0;

    do {
        retry++;

        /*  Make sure we don't read garbage later instead of    */
        /* the response we expect from the micro.               */
        ClearSerialPortBuffers(IspEnvironment);

        /*  Send the packet, the size is the number of data     */
        /* bytes in the packet plus 3 bytes worth of header     */
        /* plus checksum.                                       */
        SendComPortBlock(IspEnvironment, packet, packet->bytes + 4);

        /*  Receive the response and check, return to caller    */
        /* if successful.                                       */
        if (ReceiveComPortBlockComplete(IspEnvironment, &response, 1, 5000) == 0)
        {
            if (response == ANALOG_DEVICES_ACK)
            {
                DebugPrintf(3, "Packet Sent\n");
                return;
            }
            if (response != ANALOG_DEVICES_NAK)
            {
                DebugPrintf(3, "Unexpected response to packet (%x)\n", (int)response);
            }
            DebugPrintf(2, "*");
        }
    } while (retry < 3);

    DebugPrintf(1, "Send packet failed\n");
    exit(-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %ebp
leaq 0x7(%rsp), %r15
leaq 0x417e(%rip), %r12      # 0xa17c
leaq 0x4153(%rip), %r13      # 0xa158
movq %r14, %rdi
callq 0x46b7
movzbl 0x2(%rbx), %edx
addq $0x4, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44ba
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
movl $0x1388, %ecx           # imm = 0x1388
callq 0x49b9
testl %eax, %eax
jne 0x6066
movzbl 0x7(%rsp), %edx
cmpl $0x7, %edx
je 0x6057
cmpl $0x6, %edx
je 0x6087
movl $0x3, %edi
movq %r13, %rsi
xorl %eax, %eax
callq 0x43fd
movl $0x2, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x43fd
decl %ebp
jne 0x6005
leaq 0x410d(%rip), %rsi      # 0xa17e
movl $0x1, %edi
xorl %eax, %eax
callq 0x43fd
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4240
leaq 0x40bd(%rip), %rsi      # 0xa14b
movl $0x3, %edi
xorl %eax, %eax
callq 0x43fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpcprog.c
// Function: FormatCommand
static void FormatCommand(const char *In, char *Out)
{
  size_t i, j;
  for (i = 0, j = 0; In[j] != '\0'; i++, j++)
  {
    if ((In[j] == '\r') || (In[j] == '\n'))
    {
      if (i > 0) // Ignore leading line breaks (they must be leftovers from a previous answer)
      {
        Out[i] = '\n';
      }
      else
      {
        i--;
      }
      while ((In[j+1] == '\r') || (In[j+1] == '\n'))
      {
        j++;
      }
    }
    else
    {
      Out[i] = In[j];
    }
  }
  Out[i] = '\0';
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
cmpl $0xa, %edx
je 0x8216
cmpl $0xd, %edx
je 0x8216
testl %edx, %edx
je 0x823e
movb %dl, (%rsi,%rax)
incq %rcx
jmp 0x8239
testq %rax, %rax
je 0x8221
movb $0xa, (%rsi,%rax)
jmp 0x8228
movq $-0x1, %rax
incq %rcx
movzbl (%rdi,%rcx), %edx
cmpl $0xd, %edx
je 0x8228
cmpl $0xa, %edx
je 0x8228
incq %rax
jmp 0x81fc
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpcprog.c
// Function: SendAndVerify
static int SendAndVerify(ISP_ENVIRONMENT *IspEnvironment, const char *Command,
                                 char *AnswerBuffer, int AnswerLength)
{
    unsigned long realsize;
    int cmdlen;
    char *FormattedCommand;

    SendComPort(IspEnvironment, Command);
    ReceiveComPort(IspEnvironment, AnswerBuffer, AnswerLength - 1, &realsize, 2, 5000);

    cmdlen = strlen(Command);
    FormattedCommand = (char *)alloca(cmdlen+1);
    FormatCommand(Command, FormattedCommand);
    FormatCommand(AnswerBuffer, AnswerBuffer);
    cmdlen = strlen(FormattedCommand);
    return (strncmp(AnswerBuffer, FormattedCommand, cmdlen) == 0
        && strcmp(AnswerBuffer + cmdlen, "0\n") == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4595
leaq -0x20(%rbp), %rcx
movl $0x7f, %edx
movl $0x2, %r8d
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1388, %r9d           # imm = 0x1388
callq 0x4724
movq %r14, %rdi
callq 0x40a0
incl %eax
cltq
movq %rsp, %r15
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq %r14, %rdi
movq %r15, %rsi
callq 0x81f8
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x81f8
movq %r15, %rdi
callq 0x40a0
movslq %eax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4060
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x82e9
cmpb $0x30, (%rbx,%r14)
jne 0x82e9
cmpb $0xa, 0x1(%rbx,%r14)
jne 0x82e9
xorl %eax, %eax
cmpb $0x0, 0x2(%rbx,%r14)
sete %al
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/lpc21isp/lpcterm.c
// Function: CheckTerminalParameters
BOOL CheckTerminalParameters(ISP_ENVIRONMENT *IspEnvironment, char* pstr)
{
    if (stricmp(pstr, "-localecho") == 0)
    {
        IspEnvironment->LocalEcho = 1;
        DebugPrintf(3, "Local echo in terminal mode.\n");
        return TRUE;
    }

    if (stricmp(pstr, "-term") == 0)
    {
        IspEnvironment->TerminalAfterUpload = 1;
        DebugPrintf(3, "Invoke terminal after upload.\n");
        return TRUE;
    }

    if (stricmp(pstr, "-termonly") == 0)
    {
        IspEnvironment->TerminalOnly    = 1;
        IspEnvironment->ProgramChip    = 0;
        DebugPrintf(3, "Only provide terminal.\n");
        return TRUE;
    }

    return FALSE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x33c5(%rip), %rsi      # 0xb9de
movq %r14, %rdi
callq 0x436c
testl %eax, %eax
je 0x8660
leaq 0x33db(%rip), %rsi      # 0xba07
movq %r14, %rdi
callq 0x436c
testl %eax, %eax
je 0x866d
leaq 0x33ed(%rip), %rsi      # 0xba2c
movq %r14, %rdi
callq 0x436c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x8689
movb $0x1, 0x30(%rbx)
movb $0x0, 0x8(%rbx)
leaq 0x33d8(%rip), %rsi      # 0xba36
jmp 0x8678
movb $0x1, 0x32(%rbx)
leaq 0x337e(%rip), %rsi      # 0xb9e9
jmp 0x8678
movb $0x1, 0x31(%rbx)
leaq 0x3395(%rip), %rsi      # 0xba0d
movl $0x3, %edi
xorl %eax, %eax
callq 0x43fd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/ref/twine.c
// Function: pstate3
void pstate3(const unsigned char* st, int len)
{
	int i;
	for(i = 0; i < len; i++){
		printf("%01x", st[i]&0xf);
		if(((i%16) == (16-1)) && (i+1 !=len)) printf("\n");
	}
	printf("\n");
}

// Assembly:
testl %esi, %esi
jle 0x17ee
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r15d
leaq -0x1(%r15), %r12
leaq 0x1936(%rip), %r14      # 0x30e0
xorl %r13d, %r13d
movzbl (%rbx,%r13), %esi
andl $0xf, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movl %r13d, %eax
notl %eax
testb $0xf, %al
setne %al
cmpq %r13, %r12
sete %cl
orb %al, %cl
jne 0x17dd
movl $0xa, %edi
callq 0x1060
incq %r13
cmpq %r13, %r15
jne 0x17ad
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/ref/twine.c
// Function: Keyschedule
int Keyschedule(const uint32 key_len, const uint8 sk[128/8])
{
	if(key_len == 80)
		Keyschedule80(sk);
	else if(key_len == 128)
		Keyschedule128(sk);
	else
		return -1;

	return 0;
}

// Assembly:
pushq %rax
cmpl $0x80, %edi
je 0x246d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x50, %edi
jne 0x2477
movq %rsi, %rdi
callq 0x1080
jmp 0x2475
movq %rsi, %rdi
callq 0x10e0
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl-sign.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 4) error(2,
        "Usage: tweetnacl-sign sign.sec message.txt message.signed");

    // This will also erroneously fail if the file "-" exists
    if (file_exists(argv[3])) errorf(1, "File <%s> exists", argv[3]);

    unsigned char secret_key[crypto_sign_SECRETKEYBYTES];
    read_key(argv[1], secret_key, crypto_sign_SECRETKEYBYTES);

    Content c = read_file(argv[2]);
    unsigned char *sm = malloc(c.size + crypto_sign_BYTES);
    unsigned long long ssize;
    crypto_sign(sm, &ssize, c.bytes, c.size, secret_key);
    free(c.bytes);

    if (strcmp(argv[3], "-") != 0) {
        FILE *out = create_file(argv[3]);
        fwrite(sm, ssize, 1, out);
        fclose(out);
    } else {
        fwrite(bytes_to_hex(sm, ssize - c.size), 
            (ssize - c.size) * 2, 1, stdout);
        fputs("\n", stdout);
    }

    free(sm);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
cmpl $0x4, %edi
je 0x39ae
leaq 0xefc(%rip), %rsi       # 0x48a0
movl $0x2, %edi
callq 0x1318
movq 0x18(%r14), %rdi
callq 0x146c
testl %eax, %eax
je 0x39d0
movq 0x18(%r14), %rdx
leaq 0xf14(%rip), %rsi       # 0x48da
movl $0x1, %edi
callq 0x1360
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
movl $0x40, %edx
callq 0x1480
movq 0x10(%r14), %rdi
callq 0x14de
movq %rax, %r15
movq %rdx, %r13
leaq 0x40(%rax), %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x2c7b
movq %r13, %rdi
callq 0x1030
movq 0x18(%r14), %rdi
cmpb $0x2d, (%rdi)
jne 0x3a2e
cmpb $0x0, 0x1(%rdi)
je 0x3a6b
callq 0x1430
movq %rax, %r14
movq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1150
movq %r14, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x8(%rsp), %esi
subl %r15d, %esi
movq %rbx, %rdi
callq 0x13b3
movq 0x8(%rsp), %rsi
subq %r15, %rsi
addq %rsi, %rsi
movq 0x354c(%rip), %r14      # 0x6fd8
movq (%r14), %rcx
movl $0x1, %edx
movq %rax, %rdi
callq 0x1150
movq (%r14), %rsi
leaq 0xe45(%rip), %rdi       # 0x48eb
callq 0x1060
jmp 0x3a53
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/analyzer/analyzer.c
// Function: getMessageByteCount
static unsigned int getMessageByteCount(const char *const msg)
{
  const char  *p;
  int          r;
  unsigned int len;

  p = strchr(msg, ',');
  if (p)
  {
    r = sscanf(p, ",%*u,%*u,%*u,%*u,%u,%*x,%*x,%*x,%*x,%*x,%*x,%*x,%*x,%*x", &len);
    if (r >= 1)
    {
      return len;
    }
  }
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x2c, %esi
callq 0xd100
testq %rax, %rax
je 0xebc8
leaq 0xff20(%rip), %rsi      # 0x1eacd
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0xd240
testl %eax, %eax
jle 0xebca
movl 0xc(%rsp), %ebx
jmp 0xebca
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/analyzer/analyzer.c
// Function: fieldPrintVariable
extern bool fieldPrintVariable(const Field   *field,
                               const char    *fieldName,
                               const uint8_t *data,
                               size_t         dataLen,
                               size_t         startBit,
                               size_t        *bits)
{
  const Field *refField;
  bool         r;

  refField = getField(g_refPgn, data[startBit / 8 - 1] - 1);
  if (refField)
  {
    logDebug("Field %s: found variable field %u '%s'\n", fieldName, g_refPgn, refField->name);
    r     = printField(refField, fieldName, data, dataLen, startBit, bits, false);
    *bits = (*bits + 7) & ~0x07; // round to bytes
    return r;
  }

  logError("Field %s: cannot derive variable length for PGN %d field # %d\n", fieldName, g_refPgn, data[-1]);
  *bits = 8; /* Gotta assume something */
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movl 0x78ae8(%rip), %edi     # 0x882f8
movq %r8, %rax
shrq $0x3, %rax
movzbl -0x1(%rdx,%rax), %esi
decl %esi
callq 0xd8fc
movl 0x78acf(%rip), %edx     # 0x882f8
testq %rax, %rax
je 0xf872
movq %rax, %rbp
movq (%rax), %rcx
leaq 0xf107(%rip), %rdi      # 0x1e942
movq %r14, %rsi
xorl %eax, %eax
callq 0x1990d
movl $0x0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xf307
movl %eax, %ebp
movq (%rbx), %rax
addq $0x7, %rax
andq $-0x8, %rax
jmp 0xf88f
movzbl -0x1(%r13), %ecx
leaq 0xf0ec(%rip), %rdi      # 0x1e96a
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x199a0
movl $0x8, %eax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexMain.c
// Function: verbose_test
void verbose_test(regex_char_t *pattern, regex_char_t *string)
{
	int error;
	regex_char_t *ptr;
	struct regex_machine* machine;
	struct regex_match* match;
	int begin, end, id;

	ptr = pattern;
	while (*ptr)
		ptr++;

	printf("Start test '%s' matches to '%s'\n", pattern, string);
	machine = regex_compile(pattern, ptr - pattern, REGEX_MATCH_VERBOSE | REGEX_NEWLINE, &error);

	if (error) {
		printf("WARNING: Error %d\n", error);
		return;
	}
	if (!machine) {
		printf("ERROR: machine must be exists. Report this bug, please\n");
		return;
	}

	match = regex_begin_match(machine);
	if (!match) {
		printf("WARNING: Not enough memory for matching\n");
		regex_free_machine(machine);
		return;
	}

	ptr = string;
	while (*ptr)
		ptr++;

	regex_continue_match_debug(match, string, ptr - string);

	begin = regex_get_result(match, &end, &id);
	printf("Math returns: %3d->%3d [%3d]\n", begin, end, id);

	regex_free_match(match);
	regex_free_machine(machine);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
cmpb $0x0, (%rbx,%r15)
leaq 0x1(%r15), %r15
jne 0x2250
leaq 0x10da2(%rip), %rdi     # 0x13004
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2080
decl %r15d
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl %r15d, %esi
movl $0x14, %edx
movq %r12, %rcx
callq 0x2824
movl (%r12), %esi
testl %esi, %esi
je 0x22a5
leaq 0x10d8c(%rip), %rdi     # 0x13025
xorl %eax, %eax
callq 0x2080
jmp 0x2332
movq %rax, %rbx
testq %rax, %rax
je 0x2310
movq %rbx, %rdi
callq 0x6631
testq %rax, %rax
je 0x231e
movq %rax, %r15
xorl %edx, %edx
cmpb $0x0, (%r14,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x22bf
decl %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6909
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x67f9
movl (%r14), %edx
movl (%r12), %ecx
leaq 0x10d3b(%rip), %rdi     # 0x13038
movl %eax, %esi
xorl %eax, %eax
callq 0x2080
movq %r15, %rdi
callq 0x67ee
jmp 0x232a
leaq 0x11186(%rip), %rdi     # 0x1349d
callq 0x2060
jmp 0x2332
leaq 0x111af(%rip), %rdi     # 0x134d4
callq 0x2060
movq %rbx, %rdi
callq 0x6616
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexMain.c
// Function: main
int main(int argc, char* argv[])
{
	int has_arg = (argc >= 2 && argv[1][0] == '-' && argv[1][2] == '\0');

/*	verbose_test("a((b)((c|d))|)c|"); */
/*	verbose_test("Xa{009,0010}Xb{,7}Xc{5,}Xd{,}Xe{1,}Xf{,1}X"); */
/*	verbose_test("{3!}({3})({0!}){,"); */
/*	verbose_test("(s(ab){2,4}t){2,}*S(a*(b)(c()|)d+){3,4}{0,0}*M"); */
/*	verbose_test("^a({2!})*b+(a|{1!}b)+d$"); */
/*	verbose_test("((a|b|c)*(xy)+)+", "asbcxyxy"); */

	run_tests(tests, has_arg && argv[1][1] == 'v', has_arg && argv[1][1] == 's');
	return 0;
}

// Assembly:
movq %rsi, %rax
xorl %esi, %esi
cmpl $0x2, %edi
jl 0x280e
movq 0x8(%rax), %rax
cmpb $0x2d, (%rax)
jne 0x280e
cmpb $0x0, 0x2(%rax)
movl $0x0, %edx
jne 0x2810
movb 0x1(%rax), %al
xorl %esi, %esi
cmpb $0x76, %al
sete %sil
xorl %edx, %edx
cmpb $0x73, %al
sete %dl
jmp 0x2810
xorl %edx, %edx
pushq %rax
leaq 0x14898(%rip), %rdi     # 0x170b0
callq 0x233e
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_destroy
static void stack_destroy(struct stack *stack)
{
	struct stack_fragment *curr = stack->first;
	struct stack_fragment *prev;

#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
	stack_check(stack);
#endif

	while (curr) {
		prev = curr;
		curr = curr->data.next;
		free(prev);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
callq 0x6c7b
testq %rbx, %rbx
je 0x4dc3
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x4db0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: trace_transitions
static int trace_transitions(int from, struct compiler_common *compiler_common)
{
	int id = 0;
	struct stack *stack = &compiler_common->stack;
	struct stack *depth = &compiler_common->depth;
	struct stack_item *dfa_transitions = compiler_common->dfa_transitions;
	struct stack_item *search_states = compiler_common->search_states;

	SLJIT_ASSERT(search_states[from].type >= 0);

	from++;

	/* Be prepared for any paths (loops, etc). */
	while (1) {
		if (dfa_transitions[from].type == type_id)
			if (id < dfa_transitions[from].value)
				id = dfa_transitions[from].value;

		if (search_states[from].value < id) {
			/* Forward step. */
			if (search_states[from].value == -1)
				if (stack_push(stack, 0, from))
					return REGEX_MEMORY_ERROR;
			search_states[from].value = id;

			if (dfa_transitions[from].type == type_branch) {
				if (stack_push(depth, id, from))
					return REGEX_MEMORY_ERROR;
				from++;
				continue;
			}
			else if (dfa_transitions[from].type == type_jump) {
				from = dfa_transitions[from].value;
				continue;
			}
			else if (search_states[from].type < 0) {
				from++;
				continue;
			}
		}

		/* Back tracking. */
		if (depth->count > 0) {
			id = stack_top(depth)->type;
			from = dfa_transitions[stack_pop(depth)->value].value;
			continue;
		}
		return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rsi), %r12
movslq %edi, %rax
cmpl $0x0, (%r12,%rax,8)
js 0x4ed2
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18(%rsi), %rax
movq %rax, (%rsp)
movq 0x58(%rsi), %r13
incl %ebp
xorl %r15d, %r15d
movslq %ebp, %r14
movl (%r13,%r14,8), %eax
cmpl $0x4, %eax
jne 0x4e17
movl 0x4(%r13,%r14,8), %ecx
cmpl %ecx, %r15d
cmovlel %ecx, %r15d
movl 0x4(%r12,%r14,8), %ecx
cmpl %r15d, %ecx
jge 0x4e6c
cmpl $-0x1, %ecx
jne 0x4e3b
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x6bbe
testl %eax, %eax
jne 0x4ea6
movl (%r13,%r14,8), %eax
movl %r15d, 0x4(%r12,%r14,8)
cmpl $0xb, %eax
je 0x4e5e
cmpl $0xa, %eax
jne 0x4e65
movq (%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x6bbe
testl %eax, %eax
je 0x4e9b
jmp 0x4ea6
movl 0x4(%r13,%r14,8), %ebp
jmp 0x4dfe
cmpl $0x0, (%r12,%r14,8)
js 0x4e9b
cmpl $0x0, 0x2c(%rbx)
jle 0x4ea2
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x4eba
movslq 0x28(%rbx), %rcx
movl 0x10(%rax,%rcx,8), %r15d
movq (%rsp), %rdi
callq 0x4ee0
movslq 0x4(%rax), %rax
movl 0x4(%r13,%rax,8), %ebp
jmp 0x4dfe
incl %ebp
jmp 0x4dfe
xorl %eax, %eax
jmp 0x4eab
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe837(%rip), %rdi      # 0x136f8
movl $0xe3, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2050
leaq 0xe81f(%rip), %rdi      # 0x136f8
movl $0x4d7, %esi            # imm = 0x4D7
jmp 0x4ec6
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_pop
static struct stack_item* stack_pop(struct stack *stack)
{
	struct stack_item *ret = stack_top(stack);

	if (stack->index > 0)
		stack->index--;
	else {
		stack->last = stack->last->data.prev;
		stack->index = STACK_FRAGMENT_SIZE - 1;
	}

	stack->count--;
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
	stack_check(stack);
#endif
	return ret;
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4f1d
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x4ef8
leal -0x1(%rcx), %edx
jmp 0x4f05
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movl $0x3d, %edx
leaq (%rax,%rcx,8), %rbx
addq $0x10, %rbx
movl %edx, 0x10(%rdi)
decl 0x14(%rdi)
callq 0x6c7b
movq %rbx, %rax
popq %rbx
retq
leaq 0xe7d4(%rip), %rdi      # 0x136f8
movl $0xe3, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: compile_newline_check
static int compile_newline_check(struct compiler_common *compiler_common, long ind)
{
	struct sljit_compiler *compiler = compiler_common->compiler;
	struct sljit_jump *jump1;
	struct sljit_jump *jump2;
	struct sljit_label *label;
	long no_states;
	long offset;

	/* Check whether a new-line character is found. */
	EMIT_CMP(jump1, SLJIT_EQUAL, R_CURR_CHAR, 0, SLJIT_IMM, '\n');
	EMIT_CMP(jump2, SLJIT_EQUAL, R_CURR_CHAR, 0, SLJIT_IMM, '\r');

	no_states = compiler_common->no_states;
	offset = TERM_OFFSET_OF(compiler_common->search_states[ind].type, 1);
	EMIT_OP1(SLJIT_MOV, R_TEMP, 0, SLJIT_MEM1(R_CURR_STATE), offset);
	EMIT_OP1(SLJIT_MOV, SLJIT_MEM1(R_CURR_STATE), offset, SLJIT_IMM, -1);
	CHECK(sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM2(R_CURR_STATE, R_TEMP), 0));

	EMIT_LABEL(label);
	sljit_set_label(jump1, label);
	sljit_set_label(jump2, label);
	return REGEX_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %r13
movq 0x68(%rdi), %r14
movl $0xa, %r9d
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x40, %r8d
callq 0x117ca
movl $0x1, %ebx
testq %rax, %rax
je 0x5d80
movq %rax, %r15
movl $0xd, %r9d
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x40, %r8d
callq 0x117ca
testq %rax, %rax
je 0x5d80
movq %rax, %r12
movq 0x60(%r13), %rax
movslq (%rax,%rbp,8), %rax
imulq 0x48(%r13), %rax
leaq 0x8(,%rax,8), %r13
movq %r14, %rdi
movl $0x20, %esi
movl $0x3, %edx
xorl %ecx, %ecx
movl $0x8c, %r8d
movq %r13, %r9
callq 0x9c63
testl %eax, %eax
jne 0x5d80
movq %r14, %rdi
movl $0x20, %esi
movl $0x8c, %edx
movq %r13, %rcx
movl $0x40, %r8d
movq $-0x1, %r9
callq 0x9c63
testl %eax, %eax
jne 0x5d80
movq %r14, %rdi
movl $0x16, %esi
movl $0x38c, %edx            # imm = 0x38C
xorl %ecx, %ecx
callq 0x10312
testl %eax, %eax
jne 0x5d80
movq %r14, %rdi
callq 0xfff6
testq %rax, %rax
je 0x5d80
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x78d1
movq %r12, %rdi
movq %r14, %rsi
callq 0x78d1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: regex_begin_match
struct regex_match* regex_begin_match(struct regex_machine *machine)
{
	long *ptr1;
	long *ptr2;
	long *end;
	long *entry_addrs;

	struct regex_match *match = malloc(sizeof(struct regex_match) + (machine->size * 2 - 1) * sizeof(long));
	if (!match)
		return NULL;

	ptr1 = match->states;
	ptr2 = match->states + machine->size;
	end = ptr2;
	entry_addrs = (long*)machine->entry_addrs;

	match->current = ptr1;
	match->next = ptr2;
	match->head = 0;
	match->machine = machine;

	/* Init machine states. */
	switch (machine->no_states) {
	case 2:
		while (ptr1 < end) {
			*ptr1++ = *entry_addrs;
			*ptr2++ = *entry_addrs++;
			*ptr1++ = -1;
			*ptr2++ = -1;
		}
		break;

	case 3:
		while (ptr1 < end) {
			*ptr1++ = *entry_addrs;
			*ptr2++ = *entry_addrs++;
			*ptr1++ = -1;
			*ptr2++ = -1;
			*ptr1++ = 0;
			*ptr2++ = 0;
		}
		break;

	case 4:
		while (ptr1 < end) {
			*ptr1++ = *entry_addrs;
			*ptr2++ = *entry_addrs++;
			*ptr1++ = -1;
			*ptr2++ = -1;
			*ptr1++ = 0;
			*ptr2++ = 0;
			*ptr1++ = 0;
			*ptr2++ = 0;
		}
		break;

	default:
		SLJIT_ASSERT_STOP();
		break;
	}

	SLJIT_ASSERT(ptr1 == end);

	match->u.continue_match = machine->continue_match;

	regex_reset_match(match);
	return match;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movq %r15, %rdi
shlq $0x4, %rdi
addq $0x58, %rdi
callq 0x20d0
movq %rax, %r14
testq %rax, %rax
je 0x6776
leaq 0x58(%r14), %rsi
leaq (,%r15,8), %rcx
leaq (%r14,%r15,8), %rdi
leaq (%r14,%r15,8), %rax
addq $0x58, %rax
leaq 0x28(%rbx), %rdx
movq %rsi, (%r14)
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
movq %rbx, 0x48(%r14)
movq 0x8(%rbx), %r8
cmpq $0x2, %r8
je 0x672d
cmpq $0x3, %r8
je 0x66f0
cmpq $0x4, %r8
jne 0x678d
testq %r15, %r15
jle 0x675e
movq $-0x1, %r8
xorl %r9d, %r9d
movq (%rdx), %rdi
movq %rdi, (%rsi)
addq $0x8, %rdx
movq %rdi, (%rsi,%rcx)
movq %r8, 0x8(%rsi)
movq %r8, 0x8(%rsi,%rcx)
movq %r9, 0x10(%rsi)
movq %r9, 0x10(%rsi,%rcx)
leaq 0x20(%rsi), %rdi
movq %r9, 0x18(%rsi)
movq %r9, 0x18(%rsi,%rcx)
movq %rdi, %rsi
cmpq %rax, %rdi
jb 0x66b9
jmp 0x6761
cmpq %rdi, %r14
jae 0x675e
movq $-0x1, %r8
xorl %r9d, %r9d
movq (%rdx), %rdi
movq %rdi, (%rsi)
addq $0x8, %rdx
movq %rdi, (%rsi,%rcx)
movq %r8, 0x8(%rsi)
movq %r8, 0x8(%rsi,%rcx)
leaq 0x18(%rsi), %rdi
movq %r9, 0x10(%rsi)
movq %r9, 0x10(%rsi,%rcx)
movq %rdi, %rsi
cmpq %rax, %rdi
jb 0x66ff
jmp 0x6761
cmpq %rdi, %r14
jae 0x675e
movq $-0x1, %r8
movq (%rdx), %rdi
movq %rdi, (%rsi)
addq $0x8, %rdx
movq %rdi, (%rsi,%rcx)
leaq 0x10(%rsi), %rdi
movq %r8, 0x8(%rsi)
movq %r8, 0x8(%rsi,%rcx)
movq %rdi, %rsi
cmpq %rax, %rdi
jb 0x6739
jmp 0x6761
movq %rsi, %rdi
cmpq %rax, %rdi
jne 0x677f
movq 0x20(%rbx), %rax
movq %rax, 0x50(%r14)
movq %r14, %rdi
callq 0x67a5
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xcf72(%rip), %rdi      # 0x136f8
movl $0x953, %esi            # imm = 0x953
jmp 0x6799
leaq 0xcfcb(%rip), %rdi      # 0x1375f
movl $0x94f, %esi            # imm = 0x94F
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: regex_reset_match
void regex_reset_match(struct regex_match *match)
{
	struct regex_machine *machine = match->machine;
	long current, ind;
	long *current_ptr;

	match->best_end = 0;
	match->fast_quit = 0;
	match->fast_forward = 0;

	if (match->head != 0) {
		/* Clear the current state. */
		current = match->head;
		current_ptr = match->current;
		do {
			ind = (current / sizeof(long)) + 1;
			current = current_ptr[ind];
			current_ptr[ind] = -1;
		} while (current != 0);
	}
	match->head = machine->u.call_init(match->current, match);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdi), %rdi
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x67e2
andq $-0x8, %rcx
movq 0x8(%rdi,%rcx), %rdx
movq $-0x1, 0x8(%rdi,%rcx)
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x67c8
movq %rbx, %rsi
callq *0x18(%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/regex_src/regexJIT.c
// Function: regex_get_result
int regex_get_result(struct regex_match *match, int *end, int *id)
{
	int flags = match->machine->flags;
	long no_states;

	*end = match->best_end;
	*id = match->best_id;
	if (!(flags & (REGEX_MATCH_END | REGEX_FAKE_MATCH_END)))
		return match->best_begin;

	if (flags & REGEX_FAKE_MATCH_END) {
		SLJIT_ASSERT(!(flags & (REGEX_MATCH_BEGIN | REGEX_MATCH_END)));
		if (match->best_begin != -1)
			return match->best_begin;

		no_states = match->machine->no_states;
		if (match->current[no_states + 1] == -1)
			return -1;
		if (flags & REGEX_ID_CHECK)
			*id = match->current[no_states + 3];
		if (!(flags & REGEX_FAKE_MATCH_BEGIN))
			*end = match->index - 1;
		else
			*end = match->index - 2;
		return match->current[no_states + 2];
	}
	else {
		/* Check the status of the last code. */
		if (!(flags & REGEX_MATCH_BEGIN)) {
			/* No shortcut in this case. */
			if (!(flags & REGEX_ID_CHECK)) {
				if (match->current[1] == -1)
					return -1;
				*end = match->index - 1;
				return match->current[2];
			}

			if (match->current[1] == -1)
				return -1;
			*end = match->index - 1;
			*id = match->current[3];
			return match->current[2];
		}

		/* Shortcut is possible in this case. */
		if (!(flags & REGEX_ID_CHECK)) {
			if (match->current[1] == -1 || match->head == -1)
				return -1;
			*end = match->index - 1;
			return 0;
		}

		if (match->current[1] == -1 || match->head == -1)
			return -1;
		*end = match->index - 1;
		*id = match->current[2];
		return 0;
	}
}

// Assembly:
movq 0x48(%rdi), %r8
movl (%r8), %ecx
movl 0x28(%rdi), %eax
movl %eax, (%rsi)
movl 0x30(%rdi), %eax
movl %eax, (%rdx)
testl $0x402, %ecx            # imm = 0x402
je 0x683d
btl $0xa, %ecx
jb 0x6841
movq (%rdi), %r8
movq 0x8(%r8), %r9
testb $0x1, %cl
jne 0x6888
btl $0x8, %ecx
jb 0x68a9
cmpq $-0x1, %r9
je 0x68c1
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
jmp 0x68bc
movl 0x20(%rdi), %eax
retq
testb $0x3, %cl
jne 0x68ec
movq 0x20(%rdi), %rax
cmpq $-0x1, %rax
jne 0x6840
movq 0x8(%r8), %rax
movq (%rdi), %r8
cmpq $-0x1, 0x8(%r8,%rax,8)
je 0x68c1
btl $0x8, %ecx
jae 0x6871
movl 0x18(%r8,%rax,8), %r9d
movl %r9d, (%rdx)
xorl %edx, %edx
btl $0x9, %ecx
setae %dl
orl $-0x2, %edx
addl 0x18(%rdi), %edx
movl %edx, (%rsi)
movl 0x10(%r8,%rax,8), %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
btl $0x8, %ecx
jb 0x68c7
cmpq $-0x1, %r9
je 0x6840
cmpq $-0x1, 0x10(%rdi)
je 0x6840
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
jmp 0x68e9
cmpq $-0x1, %r9
je 0x68c1
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
movl 0x18(%r8), %eax
movl %eax, (%rdx)
movl 0x10(%r8), %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
cmpq $-0x1, %r9
je 0x6840
cmpq $-0x1, 0x10(%rdi)
je 0x6840
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
movl 0x10(%r8), %eax
movl %eax, (%rdx)
xorl %eax, %eax
retq
pushq %rax
leaq 0xce04(%rip), %rdi      # 0x136f8
movl $0x987, %esi            # imm = 0x987
xorl %eax, %eax
callq 0x2080
callq 0x2050