LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x4723
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 0x7e38
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x7e38
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 0x7f2d
addq %r14, %rbx
leaq 0x284d(%rip), %rsi      # 0xa769
movq %rbx, %rdi
callq 0x4120
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bokunimowakaru[P]petit15term/lpc21isp/lpcprog.c
// Function: GetAndReportErrorNumber
static unsigned char GetAndReportErrorNumber(const char *Answer)
{
    unsigned char Result = 0xFF;                            // Error !!!
    unsigned int i = 0;

    while (1)
    {
        if (Answer[i] == 0x00)
        {
            break;
        }

        if (Answer[i] == 0x0a)
        {
            i++;

            if (Answer[i] < '0' || Answer[i] > '9')
            {
                DebugPrintf(1, "ErrorString: %s", &Answer[i]);
                break;
            }

            Result = (unsigned char) (atoi(&Answer[i]));
            break;
        }

        i++;
    }

    NxpOutputErrorMessage(Result);

    return Result;
}

// Assembly:
pushq %rbx
movl $0x1, %eax
leal -0x1(%rax), %ecx
movzbl (%rdi,%rcx), %ecx
testl %ecx, %ecx
je 0x7f74
cmpl $0xa, %ecx
je 0x7f52
incl %eax
jmp 0x7f3e
movl %eax, %eax
leaq (%rdi,%rax), %rdx
movb (%rdi,%rax), %al
addb $-0x3a, %al
cmpb $-0xb, %al
ja 0x7f78
leaq 0x2e97(%rip), %rsi      # 0xadff
movl $0x1, %edi
xorl %eax, %eax
callq 0x43fd
movb $-0x1, %bl
jmp 0x7f82
movq %rdx, %rdi
callq 0x4220
movl %eax, %ebx
movzbl %bl, %edx
cmpb $0x13, %dl
ja 0x7fa6
leaq 0x2257(%rip), %rax      # 0xa1e8
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x2e6e(%rip), %rsi      # 0xae0f
jmp 0x807f
cmpl $0xff, %edx
je 0x808b
leaq 0x336e(%rip), %rsi      # 0xb327
movl $0x1, %edi
xorl %eax, %eax
callq 0x43fd
jmp 0x808b
leaq 0x32b5(%rip), %rsi      # 0xb286
jmp 0x807f
leaq 0x3216(%rip), %rsi      # 0xb1f3
jmp 0x807f
leaq 0x3161(%rip), %rsi      # 0xb14a
jmp 0x807f
leaq 0x2eb4(%rip), %rsi      # 0xaea9
jmp 0x807f
leaq 0x317e(%rip), %rsi      # 0xb17f
jmp 0x807f
leaq 0x309f(%rip), %rsi      # 0xb0a9
jmp 0x807f
leaq 0x2e1a(%rip), %rsi      # 0xae2d
jmp 0x807f
leaq 0x325e(%rip), %rsi      # 0xb27a
jmp 0x807f
leaq 0x2e41(%rip), %rsi      # 0xae66
jmp 0x807f
leaq 0x2ff5(%rip), %rsi      # 0xb023
jmp 0x807f
leaq 0x2de5(%rip), %rsi      # 0xae1c
jmp 0x807f
leaq 0x326d(%rip), %rsi      # 0xb2ad
jmp 0x807f
leaq 0x2ef5(%rip), %rsi      # 0xaf3e
jmp 0x807f
leaq 0x3173(%rip), %rsi      # 0xb1c5
jmp 0x807f
leaq 0x2f7d(%rip), %rsi      # 0xafd8
jmp 0x807f
leaq 0x3278(%rip), %rsi      # 0xb2dc
jmp 0x807f
leaq 0x30a6(%rip), %rsi      # 0xb113
jmp 0x807f
leaq 0x3021(%rip), %rsi      # 0xb097
jmp 0x807f
leaq 0x328a(%rip), %rsi      # 0xb309
movl $0x1, %edi
xorl %eax, %eax
callq 0x43fd
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3810(%rip), %rsi      # 0xb941
movq %r14, %rdi
callq 0x436c
testl %eax, %eax
je 0x8178
leaq 0x3826(%rip), %rsi      # 0xb96a
movq %r14, %rdi
callq 0x436c
testl %eax, %eax
je 0x8185
leaq 0x3838(%rip), %rsi      # 0xb98f
movq %r14, %rdi
callq 0x436c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x81a1
movb $0x1, 0x30(%rbx)
movb $0x0, 0x8(%rbx)
leaq 0x3823(%rip), %rsi      # 0xb999
jmp 0x8190
movb $0x1, 0x32(%rbx)
leaq 0x37c9(%rip), %rsi      # 0xb94c
jmp 0x8190
movb $0x1, 0x31(%rbx)
leaq 0x37e0(%rip), %rsi      # 0xb970
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_O1/oridb[P]mc/muse/muse.c
// Function: usage
static void
usage(char *prog)
{
	printf("%s [-hIdos] [-o outfile] [-p pkgname] [-m] inputs\n", prog);
	printf("\t-h\tprint this help\n");
	printf("\t\tThe outfile must be the same name as each package merged.\n");
	printf("\t-d\tPrint debug dumps\n");
	printf("\t-o out\tOutput to outfile\n");
	printf("\t-s\tShow the contents of usefiles `inputs`\n");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x139e0(%rip), %rdi     # 0x16088
xorl %eax, %eax
callq 0x20c0
leaq 0x13a17(%rip), %rdi     # 0x160cd
callq 0x2050
leaq 0x13a1f(%rip), %rdi     # 0x160e1
callq 0x2050
leaq 0x13a4f(%rip), %rdi     # 0x1611d
callq 0x2050
leaq 0x13a59(%rip), %rdi     # 0x16133
callq 0x2050
leaq 0x13a67(%rip), %rdi     # 0x1614d
popq %rax
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/ref/cloc.c
// Function: ae_init
int ae_init(ae_cxt* cxt, const byte* userkey, int keylen)
{
	if(keylen/8 != CRYPTO_KEYBYTES){
		return KEY_ERROR;
	}
	cxt->userkey = (byte*)userkey;
	Keyschedule(keylen, userkey);
	cxt->klen = keylen;

	return SUCCESS;
}

// Assembly:
movl %edx, %ecx
andl $-0x8, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x50, %ecx
jne 0x124c
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, 0x10(%rdi)
movl %edx, %edi
callq 0x10b0
movl %ebx, 0x18(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
		unsigned char *c, unsigned long long *clen,
		const unsigned char *m, unsigned long long mlen,
		const unsigned char *ad, unsigned long long adlen,
		const unsigned char *nsec,                          //not relavent to CLOC
		const unsigned char *npub,
		const unsigned char *k
		)
{
    /* set ciphertext length */
    *clen = mlen + CRYPTO_ABYTES;
    
    unsigned char tag[CRYPTO_ABYTES];
    ae_cxt cxt;
    
    /* set key and compute round keys */
    ae_init(&cxt, k, CRYPTO_KEYBYTES * 8);
    
    /* process the associated data */
    process_ad(&cxt, ad, adlen, npub, CRYPTO_NPUBBYTES);
    
    /* encrypt message */
    ae_encrypt(&cxt, (unsigned char*)m, mlen, c, tag, CRYPTO_ABYTES, ENC);
    
    /* copy the tag to the end of ciphertext */
    memcpy(c+mlen, tag, CRYPTO_ABYTES);
	return RETURN_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0xd0(%rsp), %rax
addq $0x4, %rcx
movq %rcx, (%rsi)
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
movl $0x50, %edx
callq 0x10c0
movl $0x6, %r8d
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0xc8(%rsp), %rcx
callq 0x1050
movl $0x1, (%rsp)
leaq 0x14(%rsp), %r12
movl $0x4, %r9d
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0x10f0
movl (%r12), %eax
movl %eax, (%r14,%rbx)
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17da
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r15d
leaq -0x1(%r15), %r12
leaq 0x198a(%rip), %r14      # 0x3120
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 0x17c9
movl $0xa, %edi
callq 0x1060
incq %r13
cmpq %r13, %r15
jne 0x1799
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x21ba
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x50, %edi
jne 0x21c4
movq %rsi, %rdi
callq 0x1080
jmp 0x21c2
movq %rsi, %rdi
callq 0x10e0
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x373e
leaq 0x115c(%rip), %rsi      # 0x4890
movl $0x2, %edi
callq 0x1334
movq 0x18(%r14), %rdi
callq 0x1488
testl %eax, %eax
je 0x3760
movq 0x18(%r14), %rdx
leaq 0x1174(%rip), %rsi      # 0x48ca
movl $0x1, %edi
callq 0x137c
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
movl $0x40, %edx
callq 0x149c
movq 0x10(%r14), %rdi
callq 0x14fa
movq %rax, %r15
movq %rdx, %r13
leaq 0x40(%rax), %rdi
callq 0x10e0
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x2b38
movq %r13, %rdi
callq 0x1030
movq 0x18(%r14), %r14
leaq 0x1121(%rip), %rsi      # 0x48db
movq %r14, %rdi
callq 0x10a0
testl %eax, %eax
je 0x37f0
movq %r14, %rdi
callq 0x144c
movq %rax, %r14
movq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1160
movq %r14, %rdi
callq 0x1050
jmp 0x3830
movl 0x8(%rsp), %esi
subl %r15d, %esi
movq %rbx, %rdi
callq 0x13cf
movq 0x8(%rsp), %rsi
subq %r15, %rsi
addq %rsi, %rsi
movq 0x37c7(%rip), %r14      # 0x6fd8
movq (%r14), %rcx
movl $0x1, %edx
movq %rax, %rdi
callq 0x1160
movq (%r14), %rsi
leaq 0x10b2(%rip), %rdi      # 0x48dd
callq 0x1060
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Joy-Division[P]tools-mgs/simple-hash.c
// Function: main
int main( int argc, char** argv ) {
	
	if ( argc < 2 )
	{
		printf( "Not enough arguments given!\nUsage: %s text\n", argv[0] );
		return 1;
	}
	uint16_t hash1;
	uint32_t hash2;
	uint32_t hash3;
	if(strlen(argv[1]) > 512) BREAK("donut: the abuse\n");
	printf("Hashing the following string:\n%s\n", argv[1]);
	hash1 = StrCode16(argv[1]);
	hash2 = StrCode24(argv[1]);
	hash3 = StrCode32(argv[1]);
	printf("Hash16(MGS1):     %04x\n", hash1);
	printf("Hash24(MGS2+):  %06x\n", hash2);
	printf("Hash32(ZoE2): %08x\n", hash3);
	printf("Done.\n");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x1, %edi
jg 0x121a
movq (%r14), %rsi
leaq 0xdf3(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1050
jmp 0x123a
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x1040
cmpq $0x201, %rax            # imm = 0x201
jb 0x1241
leaq 0xe65(%rip), %rdi       # 0x209a
callq 0x1030
movl $0x1, %ebx
jmp 0x12b6
leaq 0xde8(%rip), %rdi       # 0x2030
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x1050
movq 0x8(%r14), %rdi
callq 0x115c
movl %eax, %ebp
movq 0x8(%r14), %rdi
callq 0x1182
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x11b7
movl %eax, %r14d
movzwl %bp, %esi
leaq 0xdd1(%rip), %rdi       # 0x2052
xorl %eax, %eax
callq 0x1050
leaq 0xddb(%rip), %rdi       # 0x206a
movl %r15d, %esi
xorl %eax, %eax
callq 0x1050
leaq 0xde0(%rip), %rdi       # 0x2080
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
leaq 0xde3(%rip), %rdi       # 0x2094
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec84
leaq 0x10e64(%rip), %rsi     # 0x1facd
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0xd240
testl %eax, %eax
jle 0xec86
movl 0xc(%rsp), %ebx
jmp 0xec86
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x79a32(%rip), %edi     # 0x892f8
movq %r8, %rax
shrq $0x3, %rax
movzbl -0x1(%rdx,%rax), %esi
decl %esi
callq 0xd96b
movl 0x79a19(%rip), %edx     # 0x892f8
testq %rax, %rax
je 0xf928
movq %rax, %rbp
movq (%rax), %rcx
leaq 0x10051(%rip), %rdi     # 0x1f942
movq %r14, %rsi
xorl %eax, %eax
callq 0x19a95
movl $0x0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xf391
movl %eax, %ebp
movq (%rbx), %rax
addq $0x7, %rax
andq $-0x8, %rax
jmp 0xf945
movzbl -0x1(%r13), %ecx
leaq 0x10036(%rip), %rdi     # 0x1f96a
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x19b28
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_O1/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 0x2848
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 0x66cc
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 0x69ae
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x689e
movl (%r14), %edx
movl (%r12), %ecx
leaq 0x10d3b(%rip), %rdi     # 0x13038
movl %eax, %esi
xorl %eax, %eax
callq 0x2080
movq %r15, %rdi
callq 0x6893
jmp 0x232a
leaq 0x11186(%rip), %rdi     # 0x1349d
callq 0x2060
jmp 0x2332
leaq 0x111af(%rip), %rdi     # 0x134d4
callq 0x2060
movq %rbx, %rdi
callq 0x66b1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x0, %ecx
cmpl $0x2, %edi
jl 0x2812
movq 0x8(%rax), %rcx
cmpb $0x2d, (%rcx)
jne 0x2810
cmpb $0x0, 0x2(%rcx)
sete %cl
jmp 0x2812
xorl %ecx, %ecx
testb %cl, %cl
je 0x2824
movq 0x8(%rax), %rdx
xorl %esi, %esi
cmpb $0x76, 0x1(%rdx)
sete %sil
xorl %edx, %edx
testb %cl, %cl
je 0x2837
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpb $0x73, 0x1(%rax)
sete %dl
pushq %rax
leaq 0x14871(%rip), %rdi     # 0x170b0
callq 0x233e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d1f
testq %rbx, %rbx
je 0x4e95
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x4e82
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4fa2
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
cmpl $0x4, (%r13,%r14,8)
jne 0x4ee7
movl 0x4(%r13,%r14,8), %eax
cmpl %eax, %r15d
cmovlel %eax, %r15d
movl 0x4(%r12,%r14,8), %eax
cmpl %r15d, %eax
jge 0x4f3c
cmpl $-0x1, %eax
jne 0x4f06
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x6c63
testl %eax, %eax
jne 0x4f76
movl %r15d, 0x4(%r12,%r14,8)
movl (%r13,%r14,8), %eax
cmpl $0xb, %eax
je 0x4f2e
cmpl $0xa, %eax
jne 0x4f35
movq (%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x6c63
testl %eax, %eax
je 0x4f6b
jmp 0x4f76
movl 0x4(%r13,%r14,8), %ebp
jmp 0x4ed0
cmpl $0x0, (%r12,%r14,8)
js 0x4f6b
cmpl $0x0, 0x2c(%rbx)
jle 0x4f72
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x4f8a
movslq 0x28(%rbx), %rcx
movl 0x10(%rax,%rcx,8), %r15d
movq (%rsp), %rdi
callq 0x4fb0
movslq 0x4(%rax), %rax
movl 0x4(%r13,%rax,8), %ebp
jmp 0x4ed0
incl %ebp
jmp 0x4ed0
xorl %eax, %eax
jmp 0x4f7b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe74b(%rip), %rdi      # 0x136dc
movl $0xe3, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2050
leaq 0xe733(%rip), %rdi      # 0x136dc
movl $0x4d7, %esi            # imm = 0x4D7
jmp 0x4f96
// File: /workspace/github_c_makefile_star2_O1/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 0x4fed
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x4fc8
leal -0x1(%rcx), %edx
jmp 0x4fd5
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 0x6d1f
movq %rbx, %rax
popq %rbx
retq
leaq 0xe6e8(%rip), %rdi      # 0x136dc
movl $0xe3, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x1133a
movl $0x1, %ebx
testq %rax, %rax
je 0x5e32
movq %rax, %r15
movl $0xd, %r9d
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x40, %r8d
callq 0x1133a
testq %rax, %rax
je 0x5e32
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 0x9cef
testl %eax, %eax
jne 0x5e32
movq %r14, %rdi
movl $0x20, %esi
movl $0x8c, %edx
movq %r13, %rcx
movl $0x40, %r8d
movq $-0x1, %r9
callq 0x9cef
testl %eax, %eax
jne 0x5e32
movq %r14, %rdi
movl $0x16, %esi
movl $0x38c, %edx            # imm = 0x38C
xorl %ecx, %ecx
callq 0xfee5
testl %eax, %eax
jne 0x5e32
movq %r14, %rdi
callq 0xfbc1
testq %rax, %rax
je 0x5e32
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x79c2
movq %r12, %rdi
movq %r14, %rsi
callq 0x79c2
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_O1/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, %r14
movq 0x10(%rdi), %r15
movq %r15, %rdi
shlq $0x4, %rdi
addq $0x58, %rdi
callq 0x20d0
testq %rax, %rax
je 0x678b
movq %rax, %rbx
leaq 0x58(%rax), %rsi
leaq (,%r15,8), %rcx
leaq (%rax,%r15,8), %rdi
leaq (%rax,%r15,8), %rax
addq $0x58, %rax
leaq 0x28(%r14), %rdx
movq %rsi, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, 0x48(%rbx)
movq 0x8(%r14), %r8
cmpq $0x2, %r8
je 0x67cf
cmpq $0x3, %r8
je 0x6792
cmpq $0x4, %r8
jne 0x682f
testq %r15, %r15
jle 0x6800
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 0x6754
jmp 0x6803
xorl %ebx, %ebx
jmp 0x6818
cmpq %rdi, %rbx
jae 0x6800
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 0x67a1
jmp 0x6803
cmpq %rdi, %rbx
jae 0x6800
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 0x67db
jmp 0x6803
movq %rsi, %rdi
cmpq %rax, %rdi
jne 0x6821
movq 0x20(%r14), %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x6847
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xceb4(%rip), %rdi      # 0x136dc
movl $0x953, %esi            # imm = 0x953
jmp 0x683b
leaq 0xcf0d(%rip), %rdi      # 0x13743
movl $0x94f, %esi            # imm = 0x94F
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x10(%rdi), %rcx
movq 0x48(%rdi), %rax
movq $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
testq %rcx, %rcx
je 0x6884
movq (%rbx), %rdx
andq $-0x8, %rcx
movq 0x8(%rdx,%rcx), %rsi
movq $-0x1, 0x8(%rdx,%rcx)
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x686a
movq (%rbx), %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68e2
btl $0xa, %ecx
jb 0x68e6
movq (%rdi), %r8
movq 0x8(%r8), %r9
testb $0x1, %cl
jne 0x692d
btl $0x8, %ecx
jb 0x694e
cmpq $-0x1, %r9
je 0x6966
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
jmp 0x6961
movl 0x20(%rdi), %eax
retq
testb $0x3, %cl
jne 0x6991
movq 0x20(%rdi), %rax
cmpq $-0x1, %rax
jne 0x68e5
movq 0x8(%r8), %rax
movq (%rdi), %r8
cmpq $-0x1, 0x8(%r8,%rax,8)
je 0x6966
btl $0x8, %ecx
jae 0x6916
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 0x696c
cmpq $-0x1, %r9
je 0x68e5
cmpq $-0x1, 0x10(%rdi)
je 0x68e5
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
jmp 0x698e
cmpq $-0x1, %r9
je 0x6966
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 0x68e5
cmpq $-0x1, 0x10(%rdi)
je 0x68e5
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
movl 0x10(%r8), %eax
movl %eax, (%rdx)
xorl %eax, %eax
retq
pushq %rax
leaq 0xcd43(%rip), %rdi      # 0x136dc
movl $0x987, %esi            # imm = 0x987
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_push
static int stack_push(struct stack *stack, int type, int value)
{
	if (stack->last) {
		stack->index++;
		if (stack->index >= STACK_FRAGMENT_SIZE) {
			stack->index = 0;
			if (!stack->last->data.next) {
				stack->last->data.next = malloc(sizeof(struct stack_fragment));
				if (!stack->last->data.next)
					return 1;
				stack->last->data.next->data.next = NULL;
				stack->last->data.next->data.prev = stack->last;
			}
			stack->last = stack->last->data.next;
		}
	}
	else if (!stack->first) {
		stack->last = malloc(sizeof(struct stack_fragment));
		if (!stack->last)
			return 1;
		stack->last->data.prev = NULL;
		stack->last->data.next = NULL;
		stack->first = stack->last;
		stack->index = 0;
	}
	else {
		stack->last = stack->first;
		stack->index = 0;
	}
	stack->last->items[stack->index].type = type;
	stack->last->items[stack->index].value = value;
	stack->count++;
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
	stack_check(stack);
#endif
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x6cbe
movl 0x10(%rbx), %eax
incl %eax
movl %eax, 0x10(%rbx)
cmpl $0x3e, %eax
jb 0x6cef
movl $0x0, 0x10(%rbx)
cmpq $0x0, (%r15)
jne 0x6cb5
movl $0x200, %edi            # imm = 0x200
callq 0x20d0
movq %rax, (%r15)
testq %rax, %rax
je 0x6d18
movq $0x0, (%rax)
movq (%r15), %rax
movq %r15, 0x8(%rax)
movq (%r15), %rax
movq %rax, 0x8(%rbx)
jmp 0x6cef
movq (%rbx), %rax
testq %rax, %rax
je 0x6ccc
movq %rax, 0x8(%rbx)
jmp 0x6ce8
movl $0x200, %edi            # imm = 0x200
callq 0x20d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6d18
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%rbx)
movl $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
movl %r14d, 0x10(%rax,%rcx,8)
movl %ebp, 0x14(%rax,%rcx,8)
incl 0x14(%rbx)
movq %rbx, %rdi
callq 0x6d1f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x6d0d
// File: /workspace/github_c_makefile_star2_O1/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_check
static void stack_check(struct stack *stack)
{
	struct stack_fragment *curr;
	int found;

	if (!stack)
		return;

	SLJIT_ASSERT(stack->index >= 0 && stack->index < STACK_FRAGMENT_SIZE);

	if (stack->first == NULL) {
		SLJIT_ASSERT(stack->first == NULL && stack->last == NULL);
		SLJIT_ASSERT(stack->index == STACK_FRAGMENT_SIZE - 1 && stack->count == 0);
		return;
	}

	found = 0;
	if (stack->last == NULL) {
		SLJIT_ASSERT(stack->index == STACK_FRAGMENT_SIZE - 1 && stack->count == 0);
		found = 1;
	}
	else
		SLJIT_ASSERT(stack->index >= 0 && stack->count >= 0);

	SLJIT_ASSERT(stack->first->data.prev == NULL);
	curr = stack->first;
	while (curr) {
		if (curr == stack->last)
			found = 1;
		if (curr->data.next)
			SLJIT_ASSERT(curr->data.next->data.prev == curr);
		curr = curr->data.next;
	}
	SLJIT_ASSERT(found);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x6dcd
movl 0x10(%rdi), %edx
cmpl $0x3e, %edx
jae 0x6dcf
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rcx, %rcx
je 0x6d5c
testq %rax, %rax
je 0x6d7e
xorl %edx, %edx
cmpl $0x0, 0x14(%rdi)
jns 0x6d8e
leaq 0xc987(%rip), %rdi      # 0x136dc
movl $0xb9, %esi
jmp 0x6dbd
testq %rax, %rax
jne 0x6e07
cmpl $0x3d, %edx
jne 0x6d70
cmpl $0x0, 0x14(%rdi)
je 0x6dcd
leaq 0xc965(%rip), %rdi      # 0x136dc
movl $0xaf, %esi
jmp 0x6dbd
cmpl $0x3d, %edx
jne 0x6df9
movl $0x1, %edx
cmpl $0x0, 0x14(%rdi)
jne 0x6df9
cmpq $0x0, 0x8(%rcx)
jne 0x6ddd
movl $0x1, %esi
cmpq %rax, %rcx
cmovel %esi, %edx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x6dc9
cmpq %rcx, 0x8(%rdi)
movq %rdi, %rcx
je 0x6d9a
leaq 0xc924(%rip), %rdi      # 0x136dc
movl $0xc1, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2050
testl %edx, %edx
je 0x6deb
popq %rax
retq
leaq 0xc906(%rip), %rdi      # 0x136dc
movl $0xab, %esi
jmp 0x6dbd
leaq 0xc8f8(%rip), %rdi      # 0x136dc
movl $0xbb, %esi
jmp 0x6dbd
leaq 0xc8ea(%rip), %rdi      # 0x136dc
movl $0xc4, %esi
jmp 0x6dbd
leaq 0xc8dc(%rip), %rdi      # 0x136dc
movl $0xb5, %esi
jmp 0x6dbd
leaq 0xc8ce(%rip), %rdi      # 0x136dc
movl $0xae, %esi
jmp 0x6dbd
// File: /workspace/github_c_makefile_star2_O1/mmcco[P]sljit/regex_src/regexJIT.c
// Function: decode_number
static const regex_char_t* decode_number(const regex_char_t *regex_string, int length, int *result)
{
	int value = 0;

	SLJIT_ASSERT(length > 0);
	if (*regex_string < '0' || *regex_string > '9') {
		*result = -1;
		return regex_string;
	}

	while (length > 0 && *regex_string >= '0' && *regex_string <= '9') {
		value = value * 10 + (*regex_string - '0');
		length--;
		regex_string++;
	}

	*result = value;
	return regex_string;
}

// Assembly:
pushq %rax
testl %esi, %esi
jle 0x6e5e
movb (%rdi), %cl
addb $-0x3a, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $-0xa, %cl
jb 0x6e57
movl %esi, %ecx
addq %rdi, %rcx
incl %esi
xorl %eax, %eax
movb (%rdi), %r8b
addb $-0x30, %r8b
cmpb $0x9, %r8b
ja 0x6e57
leal (%rax,%rax,4), %eax
movzbl %r8b, %r8d
leal (%r8,%rax,2), %eax
incq %rdi
decl %esi
cmpl $0x1, %esi
jg 0x6e32
movq %rcx, %rdi
movl %eax, (%rdx)
movq %rdi, %rax
popq %rcx
retq
leaq 0xc877(%rip), %rdi      # 0x136dc
movl $0x199, %esi            # imm = 0x199
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_push_copy
static int stack_push_copy(struct stack *stack, int items, int length)
{
	struct stack_fragment *frag1;
	int ind1;
	struct stack_fragment *frag2;
	int ind2;
	int counter;

	SLJIT_ASSERT(stack->count >= length && items <= length && items > 0);

	/* Allocate the necessary elements. */
	counter = items;
	frag1 = stack->last;
	ind1 = stack->index;
	while (counter > 0) {
		if (stack->index + counter >= STACK_FRAGMENT_SIZE) {
			counter -= STACK_FRAGMENT_SIZE - stack->index - 1 + 1;
			stack->index = 0;
			if (!stack->last->data.next) {
				stack->last->data.next = malloc(sizeof(struct stack_fragment));
				if (!stack->last->data.next)
					return 1;
				stack->last->data.next->data.next = NULL;
				stack->last->data.next->data.prev = stack->last;
			}
			stack->last = stack->last->data.next;
		}
		else {
			stack->index += counter;
			counter = 0;
		}
	}

	frag2 = stack->last;
	ind2 = stack->index;
	while (length > 0) {
		frag2->items[ind2--] = frag1->items[ind1--];
		if (ind1 < 0) {
			ind1 = STACK_FRAGMENT_SIZE - 1;
			frag1 = frag1->data.prev;
		}
		if (ind2 < 0) {
			ind2 = STACK_FRAGMENT_SIZE - 1;
			frag2 = frag2->data.prev;
		}
		length--;
	}

#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
	stack_check(stack);
#endif
	stack->count += items;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, 0x14(%rdi)
jl 0x725e
testl %esi, %esi
jle 0x725e
movl %edx, %ebp
cmpl %edx, %esi
jg 0x725e
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
movl 0x10(%rdi), %r12d
movl %r12d, %ebx
movl %esi, 0xc(%rsp)
movl %esi, %r13d
leal (%rbx,%r13), %eax
cmpl $0x3e, %eax
jb 0x71d9
movl $0x0, 0x10(%r14)
movq 0x8(%r14), %r15
cmpq $0x0, (%r15)
jne 0x71c7
movl $0x200, %edi            # imm = 0x200
callq 0x20d0
movq %rax, (%r15)
testq %rax, %rax
je 0x7257
movq $0x0, (%rax)
movq (%r15), %rax
movq %r15, 0x8(%rax)
addl %ebx, %r13d
addl $-0x3e, %r13d
movq (%r15), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x71e0
movl %eax, 0x10(%r14)
xorl %r13d, %r13d
movl %eax, %ebx
testl %r13d, %r13d
jg 0x7188
testl %ebp, %ebp
movq 0x10(%rsp), %rdi
jle 0x7236
movl 0x10(%r14), %ecx
movq 0x8(%r14), %rax
incl %ebp
movslq %ecx, %rdx
movslq %r12d, %rsi
movq 0x10(%rdi,%rsi,8), %rsi
movq %rsi, 0x10(%rax,%rdx,8)
testl %r12d, %r12d
jle 0x7214
decl %r12d
jmp 0x721e
movq 0x8(%rdi), %rdi
movl $0x3d, %r12d
testl %ecx, %ecx
jle 0x7226
decl %ecx
jmp 0x722f
movq 0x8(%rax), %rax
movl $0x3d, %ecx
decl %ebp
cmpl $0x1, %ebp
jg 0x71fa
movq %r14, %rdi
callq 0x6d1f
movl 0xc(%rsp), %eax
addl %eax, 0x14(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x7248
leaq 0xc477(%rip), %rdi      # 0x136dc
movl $0x12c, %esi            # imm = 0x12C
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/mmcco[P]sljit/regex_src/regexJIT.c
// Function: handle_iteratives
static struct stack_item* handle_iteratives(struct stack_item *transitions_ptr, struct stack_item *transitions, struct stack *depth)
{
	struct stack_item *item;

	while (1) {
		item = stack_top(depth);

		switch (item->type) {
		case type_asterisk:
			SLJIT_ASSERT(transitions[item->value].type == type_branch);
			transitions[item->value].value = transitions_ptr - transitions;
			PUT_TRANSITION(type_branch, item->value + 1);
			break;

		case type_plus_sign:
			SLJIT_ASSERT(transitions[item->value].type == type_branch);
			transitions[item->value].value = transitions_ptr - transitions;
			break;

		case type_qestion_mark:
			PUT_TRANSITION(type_branch, item->value);
			break;

		default:
			return transitions_ptr;
		}
		stack_pop(depth);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x7319
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x10(%rbx), %rcx
movl 0x10(%rax,%rcx,8), %edx
cmpl $0x11, %edx
je 0x72f0
cmpl $0x10, %edx
je 0x72d3
cmpl $0xf, %edx
jne 0x7327
movslq 0x14(%rax,%rcx,8), %rdx
cmpl $0xa, (%r14,%rdx,8)
jne 0x7330
movq %r15, %rsi
subq %r14, %rsi
shrq $0x3, %rsi
movl %esi, 0x4(%r14,%rdx,8)
movl $0xa, -0x8(%r15)
movl 0x14(%rax,%rcx,8), %eax
incl %eax
jmp 0x72fc
movslq 0x14(%rax,%rcx,8), %rax
cmpl $0xa, (%r14,%rax,8)
jne 0x733e
movq %r15, %rcx
subq %r14, %rcx
shrq $0x3, %rcx
movl %ecx, 0x4(%r14,%rax,8)
jmp 0x7304
movl $0xa, -0x8(%r15)
movl 0x14(%rax,%rcx,8), %eax
movl %eax, -0x4(%r15)
addq $-0x8, %r15
movq %rbx, %rdi
callq 0x4fb0
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x7291
leaq 0xc3bc(%rip), %rdi      # 0x136dc
movl $0xe3, %esi
jmp 0x734a
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc3a5(%rip), %rdi      # 0x136dc
movl $0x3bb, %esi            # imm = 0x3BB
jmp 0x734a
leaq 0xc397(%rip), %rdi      # 0x136dc
movl $0x3c1, %esi            # imm = 0x3C1
xorl %eax, %eax
callq 0x2080
callq 0x2050
nop
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: set_shutdown
void *set_shutdown()
{
	printf("[SIGNAL] : Got shutdown signal\n");
	msgctl(msgid_Send_Main, IPC_RMID, 0);
	printf("[SIGNAL] : Message passing queue marked for deletion\n");
	msgctl(msgid_Recv_Main, IPC_RMID, 0);
	printf("[SIGNAL] : Message passing queue marked for deletion\n");
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xd1e(%rip), %rdi       # 0x20ef
callq 0x1060
movl 0x2d90(%rip), %edi      # 0x416c
xorl %esi, %esi
xorl %edx, %edx
callq 0x10f0
leaq 0xd22(%rip), %rbx       # 0x210e
movq %rbx, %rdi
callq 0x1060
movl 0x2d76(%rip), %edi      # 0x4170
xorl %esi, %esi
xorl %edx, %edx
callq 0x10f0
movq %rbx, %rdi
callq 0x1060
movl $0x1, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: send_msg
void* send_msg() {
	msg buf;
	buf.type = pid;

	char buffer[BUFFER_SIZE];
	int choice;

	while (1) {
		if(finalcheck) {break;}
		if(check2 == 1){
			printf("\n");
			printf("1. Hit\n");
			printf("2. Stand\n");
			printf("Please choose 1 or 2: ");
			fflush(stdout);
			scanf("%d", &choice);

			if (choice == 1)
			{
				strcpy(buffer, HIT);
				printf("Sending: %s\n", buffer);

				strncpy(buf.data, buffer, BUFFER_SIZE);
				msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);
				buffer[0]='\0';
				check2 =2;

			}
			else if (choice == 2)
			{
				strcpy(buffer, STAND);
				printf("Sending: %s\n", buffer);
				strncpy(buf.data, buffer, BUFFER_SIZE);
				msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);
				buffer[0]='\0';	
				check2 = 0;
				check = 0;
				finalcheck = 1;
				break;
			}
			else
				printf("Unrecognized choice. Choose again.\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movslq 0x2d47(%rip), %rax      # 0x4174
movq %rax, -0x78(%rbp)
cmpl $0x0, 0x2d30(%rip)      # 0x4168
jne 0x1586
leaq 0xc24(%rip), %r12       # 0x2069
movq 0x2b84(%rip), %r15      # 0x3fd0
leaq 0xc0a(%rip), %r13       # 0x205d
leaq -0x2c(%rbp), %rbx
leaq -0x50(%rbp), %r14
cmpl $0x1, 0x2d02(%rip)      # 0x4164
jne 0x1511
movl $0xa, %edi
callq 0x1040
leaq 0xcca(%rip), %rdi       # 0x2143
callq 0x1060
leaq 0xcc5(%rip), %rdi       # 0x214a
callq 0x1060
movq %r12, %rdi
xorl %eax, %eax
callq 0x1090
movq (%r15), %rdi
callq 0x10e0
movq %r13, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1110
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x14c4
cmpl $0x2, %eax
je 0x1520
leaq 0xc96(%rip), %rdi       # 0x2153
callq 0x1060
jmp 0x1511
movl $0x544948, -0x50(%rbp)  # imm = 0x544948
leaq 0xbae(%rip), %rdi       # 0x2080
movq %r14, %rsi
xorl %eax, %eax
callq 0x1090
movl $0x20, %edx
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x1050
movl 0x2c79(%rip), %edi      # 0x416c
movl $0x28, %edx
leaq -0x78(%rbp), %rsi
xorl %ecx, %ecx
callq 0x10b0
movb $0x0, -0x50(%rbp)
movl $0x2, 0x2c53(%rip)      # 0x4164
cmpl $0x0, 0x2c50(%rip)      # 0x4168
je 0x145b
jmp 0x1586
leaq -0x50(%rbp), %rbx
movw $0x44, 0x4(%rbx)
movl $0x4e415453, (%rbx)     # imm = 0x4E415453
leaq 0xb49(%rip), %rdi       # 0x2080
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1090
leaq -0x70(%rbp), %rdi
movl $0x20, %edx
movq %rbx, %rsi
callq 0x1050
movl 0x2c11(%rip), %edi      # 0x416c
leaq -0x78(%rbp), %rsi
movl $0x28, %edx
xorl %ecx, %ecx
callq 0x10b0
movb $0x0, (%rbx)
movl %r14d, 0x2bef(%rip)     # 0x4164
movl %r14d, 0x2be4(%rip)     # 0x4160
movl $0x1, 0x2be2(%rip)      # 0x4168
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: play_game
void* play_game() {

	// recv_msg, send_msg 스레드 생성...
	pthread_create(&threads[1], NULL, recv_msg, NULL);
	pthread_create(&threads[2], NULL, send_msg, NULL);
	int tid;
	// 스레드들 끝날때까지 대기후 삭제...
	for (tid = 1; tid < 2; ++tid)
		pthread_join(threads[tid], NULL);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x26dc(%rip), %rdi      # 0x4188
leaq -0x51e(%rip), %rdx      # 0x1595
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1100
leaq 0x26cd(%rip), %rdi      # 0x4190
leaq -0x6b5(%rip), %rdx      # 0x1415
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1100
movq 0x26ae(%rip), %rdi      # 0x4188
xorl %esi, %esi
popq %rbp
jmp 0x1130