LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x458c
pushq $0x7f
popq %rdx
leaq -0x20(%rbp), %rcx
pushq $0x2
popq %r8
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1388, %r9d           # imm = 0x1388
callq 0x46fa
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 0x7ade
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x7ade
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 0x7bd3
cmpb $0x30, (%rbx,%r14)
jne 0x7bd3
cmpb $0xa, 0x1(%rbx,%r14)
jne 0x7bd3
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_O2/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 0x3a71(%rip), %rsi      # 0xb93e
movq %r14, %rdi
callq 0x436c
testl %eax, %eax
je 0x7f14
leaq 0x3a87(%rip), %rsi      # 0xb967
movq %r14, %rdi
callq 0x436c
testl %eax, %eax
je 0x7f21
leaq 0x3a99(%rip), %rsi      # 0xb98c
movq %r14, %rdi
callq 0x436c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x7f39
movb $0x1, 0x30(%rbx)
movb $0x0, 0x8(%rbx)
leaq 0x3a84(%rip), %rsi      # 0xb996
jmp 0x7f2c
movb $0x1, 0x32(%rbx)
leaq 0x3a2a(%rip), %rsi      # 0xb949
jmp 0x7f2c
movb $0x1, 0x31(%rbx)
leaq 0x3a41(%rip), %rsi      # 0xb96d
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x43f9
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11b23(%rip), %rdi     # 0x14088
xorl %eax, %eax
callq 0x20c0
leaq 0x11b5a(%rip), %rdi     # 0x140cd
callq 0x2050
leaq 0x11b62(%rip), %rdi     # 0x140e1
callq 0x2050
leaq 0x11b92(%rip), %rdi     # 0x1411d
callq 0x2050
leaq 0x11b9c(%rip), %rdi     # 0x14133
callq 0x2050
leaq 0x11baa(%rip), %rdi     # 0x1414d
popq %rax
jmp 0x2050
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %eax
andl $-0x8, %eax
cmpl $0x50, %eax
jne 0x1248
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
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rdi, %r14
movq 0xd0(%rsp), %rax
addq $0x4, %rcx
movq %rcx, (%rsi)
leaq 0x18(%rsp), %rbp
pushq $0x50
popq %rdx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x10c0
pushq $0x6
popq %r8
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0xc8(%rsp), %rcx
callq 0x1050
movl $0x1, (%rsp)
leaq 0x14(%rsp), %r15
pushq $0x4
popq %r9
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x10f0
movl (%r15), %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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r15d
movl %esi, %eax
sarl $0x1f, %eax
andnl %esi, %eax, %r12d
decq %r15
leaq 0x193b(%rip), %r14      # 0x30e0
pushq $0xa
popq %rbp
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x17e5
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, %r15
sete %cl
orb %al, %cl
cmpb $0x1, %cl
je 0x17e0
movl %ebp, %edi
callq 0x1060
incq %r13
jmp 0x17ab
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0x327c
leaq 0x16ac(%rip), %rsi      # 0x4920
pushq $0x2
popq %rdi
callq 0x12d4
movq 0x18(%r14), %rdi
callq 0x141c
testl %eax, %eax
je 0x329c
movq 0x18(%r14), %rdx
leaq 0x16c6(%rip), %rsi      # 0x495a
pushq $0x1
popq %rdi
callq 0x1316
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %r12
pushq $0x40
popq %rdx
movq %r12, %rsi
callq 0x1430
movq 0x10(%r14), %rdi
callq 0x148a
movq %rax, %r15
movq %rdx, %r13
leaq 0x40(%rax), %rdi
callq 0x10b0
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x2873
movq %r13, %rdi
callq 0x1030
movq 0x18(%r14), %rdi
cmpb $0x2d, (%rdi)
jne 0x32f8
cmpb $0x0, 0x1(%rdi)
je 0x3333
callq 0x13e2
movq %rax, %r14
movq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1130
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 0x1367
movq 0x8(%rsp), %rsi
subq %r15, %rsi
addq %rsi, %rsi
movq 0x3c84(%rip), %r14      # 0x6fd8
movq (%r14), %rcx
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1130
movq (%r14), %rsi
leaq 0x15ff(%rip), %rdi      # 0x496b
callq 0x1060
jmp 0x331b
// File: /workspace/github_c_makefile_star2_O2/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 0x11fa
movq (%r14), %rsi
leaq 0xe13(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1050
jmp 0x121a
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x1040
cmpq $0x201, %rax            # imm = 0x201
jb 0x121f
leaq 0xe85(%rip), %rdi       # 0x209a
callq 0x1030
pushq $0x1
popq %rbx
jmp 0x1294
leaq 0xe0a(%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 0x117a
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x11a0
movl %eax, %r14d
movzwl %bp, %esi
leaq 0xdf3(%rip), %rdi       # 0x2052
xorl %eax, %eax
callq 0x1050
leaq 0xdfd(%rip), %rdi       # 0x206a
movl %r15d, %esi
xorl %eax, %eax
callq 0x1050
leaq 0xe02(%rip), %rdi       # 0x2080
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
leaq 0xe05(%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_O2/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
pushq $0x2c
popq %rsi
callq 0xd100
testq %rax, %rax
je 0xea95
leaq 0x10053(%rip), %rsi     # 0x1eacd
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0xd240
testl %eax, %eax
jle 0xea97
movl 0xc(%rsp), %ebx
jmp 0xea97
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x78a79(%rip), %edi     # 0x882f8
movq %r8, %rax
shrq $0x3, %rax
movzbl -0x1(%rdx,%rax), %esi
decl %esi
callq 0xd8de
movl 0x78a60(%rip), %edx     # 0x882f8
testq %rax, %rax
je 0xf8de
movq %rax, %rbp
movq (%rax), %rcx
leaq 0xf098(%rip), %rdi      # 0x1e942
movq %r14, %rsi
xorl %eax, %eax
callq 0x19050
andl $0x0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xf196
movl %eax, %ebp
movq (%rbx), %rax
addq $0x7, %rax
andq $-0x8, %rax
jmp 0xf8f9
movzbl -0x1(%r13), %ecx
leaq 0xf080(%rip), %rdi      # 0x1e96a
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x190e1
pushq $0x8
popq %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xfda2(%rip), %rdi      # 0x12004
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2080
decl %r15d
pushq $0x14
popq %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rcx
callq 0x27f4
movl (%r12), %esi
testl %esi, %esi
je 0x22a3
leaq 0xfd8e(%rip), %rdi      # 0x12025
xorl %eax, %eax
callq 0x2080
jmp 0x2330
movq %rax, %rbx
testq %rax, %rax
je 0x230e
movq %rbx, %rdi
callq 0x6259
testq %rax, %rax
je 0x231c
movq %rax, %r15
xorl %edx, %edx
cmpb $0x0, (%r14,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x22bd
decl %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x64eb
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x63e0
movl (%r14), %edx
movl (%r12), %ecx
leaq 0xfd3d(%rip), %rdi      # 0x12038
movl %eax, %esi
xorl %eax, %eax
callq 0x2080
movq %r15, %rdi
callq 0x63d5
jmp 0x2328
leaq 0x10188(%rip), %rdi     # 0x1249d
callq 0x2060
jmp 0x2330
leaq 0x101b1(%rip), %rdi     # 0x124d4
callq 0x2060
movq %rbx, %rdi
callq 0x623e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27e0
movq 0x8(%rax), %rax
cmpb $0x2d, (%rax)
jne 0x27e0
cmpb $0x0, 0x2(%rax)
movl $0x0, %edx
jne 0x27e2
movb 0x1(%rax), %al
xorl %esi, %esi
cmpb $0x76, %al
sete %sil
xorl %edx, %edx
cmpb $0x73, %al
sete %dl
jmp 0x27e2
xorl %edx, %edx
pushq %rax
leaq 0x158c6(%rip), %rdi     # 0x180b0
callq 0x233c
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x685a
testq %rbx, %rbx
je 0x5e5a
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
jmp 0x5e45
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r13
movslq %edi, %rax
cmpl $0x0, (%r13,%rax,8)
js 0x5f4c
movl %edi, %r15d
leaq 0x18(%rsi), %r14
movq %rsi, (%rsp)
movq 0x58(%rsi), %rbp
incl %r15d
xorl %r12d, %r12d
movslq %r15d, %rbx
movl (%rbp,%rbx,8), %eax
cmpl $0x4, %eax
jne 0x5eac
movl 0x4(%rbp,%rbx,8), %ecx
cmpl %ecx, %r12d
cmovlel %ecx, %r12d
movl 0x4(%r13,%rbx,8), %ecx
cmpl %r12d, %ecx
jge 0x5f03
cmpl $-0x1, %ecx
jne 0x5ed1
movq (%rsp), %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x67a8
testl %eax, %eax
jne 0x5f3a
movl (%rbp,%rbx,8), %eax
movl %r12d, 0x4(%r13,%rbx,8)
cmpl $0xb, %eax
je 0x5ef4
cmpl $0xa, %eax
jne 0x5efb
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x67a8
testl %eax, %eax
je 0x5f2e
jmp 0x5f3a
movl 0x4(%rbp,%rbx,8), %r15d
jmp 0x5e95
cmpl $0x0, (%r13,%rbx,8)
js 0x5f2e
movq (%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x5f36
movq %r14, %rdi
callq 0x6e27
movl (%rax), %r12d
movq %r14, %rdi
callq 0x5f64
movslq 0x4(%rax), %rax
movl 0x4(%rbp,%rax,8), %r15d
jmp 0x5e95
incl %r15d
jmp 0x5e95
xorl %eax, %eax
jmp 0x5f3d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc7a5(%rip), %rdi      # 0x126f8
movl $0x4d7, %esi            # imm = 0x4D7
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6e27
movq %rax, %r14
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x5f7e
decl %eax
jmp 0x5f8d
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
pushq $0x3d
popq %rax
movl %eax, 0x10(%rbx)
decl 0x14(%rbx)
movq %rbx, %rdi
callq 0x685a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6363
leaq (%rax,%r15,8), %rcx
addq $0x58, %rcx
addq $0x58, %rax
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
andq $0x0, 0x10(%r14)
leaq 0x28(%rbx), %rdx
movq %rbx, 0x48(%r14)
movq 0x8(%rbx), %rsi
cmpq $0x2, %rsi
je 0x6349
cmpq $0x3, %rsi
je 0x6325
cmpq $0x4, %rsi
jne 0x637a
cmpq %rcx, %rax
jae 0x634e
movq (%rdx), %rsi
movq %rsi, (%rax)
movq %rsi, (%rax,%r15,8)
orq $-0x1, 0x8(%rax)
orq $-0x1, 0x8(%rax,%r15,8)
andq $0x0, 0x10(%rax)
andq $0x0, 0x10(%rax,%r15,8)
andq $0x0, 0x18(%rax)
andq $0x0, 0x18(%rax,%r15,8)
addq $0x8, %rdx
addq $0x20, %rax
jmp 0x62bf
movq (%rdx), %rsi
movq %rsi, (%rax)
movq %rsi, (%rax,%r15,8)
orq $-0x1, 0x8(%rax)
orq $-0x1, 0x8(%rax,%r15,8)
andq $0x0, 0x10(%rax)
andq $0x0, 0x10(%rax,%r15,8)
addq $0x8, %rdx
addq $0x18, %rax
cmpq %rcx, %rax
jb 0x62fd
jmp 0x634e
movq (%rdx), %rsi
movq %rsi, (%rax)
movq %rsi, (%rax,%r15,8)
orq $-0x1, 0x8(%rax)
orq $-0x1, 0x8(%rax,%r15,8)
addq $0x8, %rdx
addq $0x10, %rax
cmpq %rcx, %rax
jb 0x632c
cmpq %rcx, %rax
jne 0x636c
movq 0x20(%rbx), %rax
movq %rax, 0x50(%r14)
movq %r14, %rdi
callq 0x6392
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc385(%rip), %rdi      # 0x126f8
movl $0x953, %esi            # imm = 0x953
jmp 0x6386
leaq 0xc3de(%rip), %rdi      # 0x1275f
movl $0x94f, %esi            # imm = 0x94F
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq (%rdi), %rdi
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x63c9
andq $-0x8, %rcx
movq 0x8(%rdi,%rcx), %rdx
orq $-0x1, 0x8(%rdi,%rcx)
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x63b2
movq %rbx, %rsi
callq *0x18(%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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)
testw $0x402, %cx             # imm = 0x402
je 0x6423
btl $0xa, %ecx
jb 0x6427
movq (%rdi), %r8
movq 0x8(%r8), %r9
testb $0x1, %cl
jne 0x646e
btl $0x8, %ecx
jb 0x648d
cmpq $-0x1, %r9
je 0x64a5
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
jmp 0x64a0
movl 0x20(%rdi), %eax
retq
testb $0x3, %cl
jne 0x64ce
movq 0x20(%rdi), %rax
cmpq $-0x1, %rax
jne 0x6426
movq 0x8(%r8), %rax
movq (%rdi), %r8
cmpq $-0x1, 0x8(%r8,%rax,8)
je 0x64a5
btl $0x8, %ecx
jae 0x6457
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
pushq $-0x1
popq %rax
btl $0x8, %ecx
jb 0x64a9
cmpq $-0x1, %r9
je 0x6426
cmpq $-0x1, 0x10(%rdi)
je 0x6426
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
jmp 0x64cb
cmpq $-0x1, %r9
je 0x64a5
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
movl 0x18(%r8), %eax
movl %eax, (%rdx)
movl 0x10(%r8), %eax
retq
pushq $-0x1
popq %rax
retq
cmpq $-0x1, %r9
je 0x6426
cmpq $-0x1, 0x10(%rdi)
je 0x6426
movl 0x18(%rdi), %eax
decl %eax
movl %eax, (%rsi)
movl 0x10(%r8), %eax
movl %eax, (%rdx)
xorl %eax, %eax
retq
pushq %rax
leaq 0xc222(%rip), %rdi      # 0x126f8
movl $0x987, %esi            # imm = 0x987
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x67fe
movl 0x10(%rbx), %ecx
incl %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x3e, %ecx
jb 0x6831
andl $0x0, 0x10(%rbx)
movq (%r15), %rax
testq %rax, %rax
jne 0x67f3
movl $0x200, %edi            # imm = 0x200
callq 0x20d0
movq %rax, (%r15)
testq %rax, %rax
je 0x6855
andq $0x0, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
movq %rax, %r15
jmp 0x6831
movq (%rbx), %r15
testq %r15, %r15
je 0x680c
movq %r15, 0x8(%rbx)
jmp 0x682b
movl $0x200, %edi            # imm = 0x200
callq 0x20d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6855
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%rbx)
andl $0x0, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
movl %r14d, 0x10(%r15,%rax,8)
movl %ebp, 0x14(%r15,%rax,8)
incl 0x14(%rbx)
movq %rbx, %rdi
callq 0x685a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x684a
// File: /workspace/github_c_makefile_star2_O2/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 0x6909
movl 0x10(%rdi), %edx
cmpl $0x3e, %edx
jae 0x690b
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rcx, %rcx
je 0x6897
testq %rax, %rax
je 0x68b9
xorl %edx, %edx
cmpl $0x0, 0x14(%rdi)
jns 0x68c7
leaq 0xbe68(%rip), %rdi      # 0x126f8
movl $0xb9, %esi
jmp 0x68f9
testq %rax, %rax
jne 0x6943
cmpl $0x3d, %edx
jne 0x68ab
cmpl $0x0, 0x14(%rdi)
je 0x6909
leaq 0xbe46(%rip), %rdi      # 0x126f8
movl $0xaf, %esi
jmp 0x68f9
cmpl $0x3d, %edx
jne 0x6935
cmpl $0x0, 0x14(%rdi)
jne 0x6935
pushq $0x1
popq %rdx
cmpq $0x0, 0x8(%rcx)
jne 0x6919
pushq $0x1
popq %rsi
testq %rcx, %rcx
je 0x6905
movq %rcx, %rdi
cmpq %rax, %rcx
cmovel %esi, %edx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x68d1
cmpq %rdi, 0x8(%rcx)
je 0x68d1
leaq 0xbe04(%rip), %rdi      # 0x126f8
movl $0xc1, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2050
testl %edx, %edx
je 0x6927
popq %rax
retq
leaq 0xbde6(%rip), %rdi      # 0x126f8
movl $0xab, %esi
jmp 0x68f9
leaq 0xbdd8(%rip), %rdi      # 0x126f8
movl $0xbb, %esi
jmp 0x68f9
leaq 0xbdca(%rip), %rdi      # 0x126f8
movl $0xc4, %esi
jmp 0x68f9
leaq 0xbdbc(%rip), %rdi      # 0x126f8
movl $0xb5, %esi
jmp 0x68f9
leaq 0xbdae(%rip), %rdi      # 0x126f8
movl $0xae, %esi
jmp 0x68f9
// File: /workspace/github_c_makefile_star2_O2/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 0x6997
movb (%rdi), %al
addb $-0x3a, %al
cmpb $-0xa, %al
jae 0x6963
pushq $-0x1
popq %rax
jmp 0x6990
movl %esi, %ecx
addq %rdi, %rcx
xorl %eax, %eax
testl %esi, %esi
jle 0x698d
movb (%rdi), %r8b
addb $-0x30, %r8b
cmpb $0x9, %r8b
ja 0x6990
imull $0xa, %eax, %r9d
movzbl %r8b, %eax
addl %r9d, %eax
decl %esi
incq %rdi
jmp 0x696a
movq %rcx, %rdi
movl %eax, (%rdx)
movq %rdi, %rax
popq %rcx
retq
leaq 0xbd5a(%rip), %rdi      # 0x126f8
movl $0x199, %esi            # imm = 0x199
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x6d57
testl %esi, %esi
jle 0x6d57
movl %edx, %ebp
cmpl %edx, %esi
jg 0x6d57
movq 0x8(%rdi), %r15
movl 0x10(%rdi), %r13d
movl %r13d, %ebx
movq %r15, %r12
movl %esi, 0xc(%rsp)
movl %esi, %r14d
testl %r14d, %r14d
jle 0x6cf7
leal (%rbx,%r14), %eax
cmpl $0x3e, %eax
jae 0x6caf
movl %eax, 0x10(%rdi)
xorl %r14d, %r14d
movl %eax, %ebx
jmp 0x6c97
andl $0x0, 0x10(%rdi)
movq (%r12), %rax
testq %rax, %rax
jne 0x6ce5
movq %rdi, 0x10(%rsp)
movl $0x200, %edi            # imm = 0x200
callq 0x20d0
movq %rax, (%r12)
testq %rax, %rax
je 0x6d52
andq $0x0, (%rax)
movq (%r12), %rax
movq %r12, 0x8(%rax)
movq 0x10(%rsp), %rdi
addl %ebx, %r14d
addl $-0x3e, %r14d
movq %rax, 0x8(%rdi)
xorl %ebx, %ebx
movq %rax, %r12
jmp 0x6c97
pushq $0x3d
popq %rax
testl %ebp, %ebp
jle 0x6d32
movslq %ebx, %rcx
movslq %r13d, %rdx
movq 0x10(%r15,%rdx,8), %rdx
movq %rdx, 0x10(%r12,%rcx,8)
testl %r13d, %r13d
jle 0x6d18
decl %r13d
jmp 0x6d1f
movq 0x8(%r15), %r15
movl %eax, %r13d
testl %ebx, %ebx
jle 0x6d27
decl %ebx
jmp 0x6d2e
movq 0x8(%r12), %r12
movl %eax, %ebx
decl %ebp
jmp 0x6cfa
movq %rdi, %rbx
callq 0x685a
movl 0xc(%rsp), %eax
addl %eax, 0x14(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x6d43
leaq 0xb99a(%rip), %rdi      # 0x126f8
movl $0x12c, %esi            # imm = 0x12C
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdi
callq 0x6e27
movl (%rax), %ecx
cmpl $0x11, %ecx
je 0x6ddb
cmpl $0x10, %ecx
je 0x6dbf
cmpl $0xf, %ecx
jne 0x6df8
movslq 0x4(%rax), %rcx
cmpl $0xa, (%r14,%rcx,8)
jne 0x6e01
movq %r15, %rdx
subq %r14, %rdx
shrq $0x3, %rdx
movl %edx, 0x4(%r14,%rcx,8)
movl $0xa, -0x8(%r15)
movl 0x4(%rax), %eax
incl %eax
jmp 0x6de6
movslq 0x4(%rax), %rax
cmpl $0xa, (%r14,%rax,8)
jne 0x6e0f
movq %r15, %rcx
subq %r14, %rcx
shrq $0x3, %rcx
movl %ecx, 0x4(%r14,%rax,8)
jmp 0x6dee
movl $0xa, -0x8(%r15)
movl 0x4(%rax), %eax
movl %eax, -0x4(%r15)
addq $-0x8, %r15
movq %rbx, %rdi
callq 0x5f64
jmp 0x6d7d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb8f0(%rip), %rdi      # 0x126f8
movl $0x3bb, %esi            # imm = 0x3BB
jmp 0x6e1b
leaq 0xb8e2(%rip), %rdi      # 0x126f8
movl $0x3c1, %esi            # imm = 0x3C1
xorl %eax, %eax
callq 0x2080
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0xd22(%rip), %rdi       # 0x20ef
callq 0x1060
movl 0x2d94(%rip), %edi      # 0x416c
xorl %esi, %esi
xorl %edx, %edx
callq 0x10f0
leaq 0xd26(%rip), %rbx       # 0x210e
movq %rbx, %rdi
callq 0x1060
movl 0x2d7a(%rip), %edi      # 0x4170
xorl %esi, %esi
xorl %edx, %edx
callq 0x10f0
movq %rbx, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O2/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 0x2d4d(%rip), %rax      # 0x4174
leaq -0x70(%rbp), %rcx
movq %rax, -0x8(%rcx)
leaq 0xc33(%rip), %r13       # 0x2069
movq 0x2b93(%rip), %r12      # 0x3fd0
leaq 0xc19(%rip), %rbx       # 0x205d
leaq -0x2c(%rbp), %r14
leaq -0x50(%rbp), %r15
cmpl $0x0, 0x2d15(%rip)      # 0x4168
jne 0x1567
cmpl $0x1, 0x2d04(%rip)      # 0x4164
jne 0x144c
pushq $0xa
popq %rdi
callq 0x1040
leaq 0xcd2(%rip), %rdi       # 0x2143
callq 0x1060
leaq 0xccd(%rip), %rdi       # 0x214a
callq 0x1060
movq %r13, %rdi
xorl %eax, %eax
callq 0x1090
movq (%r12), %rdi
callq 0x10e0
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1110
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x14bd
cmpl $0x2, %eax
je 0x150b
leaq 0xc9d(%rip), %rdi       # 0x2153
callq 0x1060
jmp 0x144c
movl $0x544948, -0x50(%rbp)  # imm = 0x544948
leaq 0xbb5(%rip), %rdi       # 0x2080
movq %r15, %rsi
xorl %eax, %eax
callq 0x1090
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
pushq $0x20
popq %rdx
callq 0x1050
movl 0x2c82(%rip), %edi      # 0x416c
leaq -0x78(%rbp), %rsi
pushq $0x28
popq %rdx
xorl %ecx, %ecx
callq 0x10b0
movb $0x0, -0x50(%rbp)
movl $0x2, 0x2c5e(%rip)      # 0x4164
jmp 0x144c
leaq -0x50(%rbp), %rbx
movw $0x44, 0x4(%rbx)
movl $0x4e415453, (%rbx)     # imm = 0x4E415453
leaq 0xb5e(%rip), %rdi       # 0x2080
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1090
pushq $0x20
popq %rdx
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x1050
movl 0x2c2b(%rip), %edi      # 0x416c
leaq -0x78(%rbp), %rsi
pushq $0x28
popq %rdx
xorl %ecx, %ecx
callq 0x10b0
andl $0x0, 0x2c0e(%rip)      # 0x4164
andl $0x0, 0x2c03(%rip)      # 0x4160
movl $0x1, 0x2c01(%rip)      # 0x4168
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27f8(%rip), %rdi      # 0x4188
leaq -0x421(%rip), %rdx      # 0x1576
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1100
leaq 0x27e9(%rip), %rdi      # 0x4190
leaq -0x59f(%rip), %rdx      # 0x140f
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1100
movq 0x27ca(%rip), %rdi      # 0x4188
xorl %esi, %esi
popq %rbp
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O2/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: main
int main() {

	char buffer[BUFFER_SIZE];
	int count = 0;
	pid = getpid();
	msg buf;

	msgid_Send_Main = msgget(KEY_VALUE_MAIN, IPC_CREAT | PERM);
	msgid_Recv_Main = msgget(KEY_VALUE_MAIN2, IPC_CREAT | PERM);

	// Signal 등록 ...
	(void)signal(SIGINT, (void(*)()) set_shutdown);

	printf("input data ==> ");
	fgets(buffer, BUFFER_SIZE, stdin);

	buf.type = 200;
	memset(buf.data, 0, sizeof(buf.data));
	strncpy(buf.data, buffer, BUFFER_SIZE);
	msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);

	// 쓴 데이터가 ‘quit’이면 while 문 벗어남...
	if (!strncmp(buf.data, "quit", 4)) {
		return 0;
	}

	// play_game 스레드 진입...
	pthread_create(&threads[0], NULL, play_game, NULL);
	// 스레드 종료 대기후 삭제...
	pthread_join(threads[0], NULL);
	printf("game end!\n");
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
callq 0x1070
movl %eax, 0x279a(%rip)      # 0x4174
movl $0xeb8c, %edi           # imm = 0xEB8C
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x277d(%rip)      # 0x416c
movl $0xeb8d, %edi           # imm = 0xEB8D
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x276c(%rip)      # 0x4170
leaq -0x64b(%rip), %rsi      # 0x13c0
pushq $0x2
popq %rdi
callq 0x10c0
leaq 0x6c5(%rip), %rdi       # 0x20df
xorl %eax, %eax
callq 0x1090
movq 0x25b0(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
leaq -0x50(%rbp), %rbx
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x10a0
leaq -0x28(%rbp), %rdi
movq $0xc8, -0x8(%rdi)
pushq $0x20
popq %rdx
movq %rbx, %rsi
callq 0x1050
movl 0x2715(%rip), %edi      # 0x416c
leaq -0x30(%rbp), %rbx
pushq $0x28
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x10b0
cmpl $0x74697571, 0x8(%rbx)  # imm = 0x74697571
je 0x1aa2
leaq 0x2708(%rip), %rdi      # 0x4180
leaq -0xfa(%rip), %rdx       # 0x1985
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1100
movq 0x26f1(%rip), %rdi      # 0x4180
xorl %esi, %esi
callq 0x1130
leaq 0x77d(%rip), %rdi       # 0x221a
callq 0x1060
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/bitfield.c
// Function: moongl_bitfieldCheck
GLbitfield bitfieldCheck(lua_State *L, int arg, int mandatory, bitfield_t *b)
/* Assuming all args from arg to end are bitfield strings */
/* returns the OR of the corresponding codes */
        {
        int first = arg;
        GLbitfield val = 0;
        while(!lua_isnoneornil(L, arg))
            val |= b->codes[checkoption(L, arg++, NULL, b->strings)];
        if(mandatory && (arg==first))
            return luaL_argerror(L, first, "string expected");
        return val;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
leal (%rax,%r15), %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x11850
testl %eax, %eax
jle 0x11cb6
movq (%r12), %rcx
movq 0x8(%r12), %rbx
movq %r14, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x11a60
cltq
orl (%rbx,%rax,4), %ebp
incl %r15d
jmp 0x11c7e
cmpl $0x0, 0xc(%rsp)
sete %al
testl %r15d, %r15d
setne %cl
orb %al, %cl
jne 0x11cea
leaq 0x29331(%rip), %rdx     # 0x3b000
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11930
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/bitfield.c
// Function: moongl_bitfieldPush
int bitfieldPush(lua_State *L, GLbitfield code, bitfield_t *b)
/* Pushes all the strings corresponding to bits contained in code */
    {
    size_t i;
    int nret = 0;
    for(i = 0; i < b->n; i++)
        {
        if((b->codes[i] & code) == b->codes[i])
            { lua_pushstring(L, b->strings[i]); nret++; }
        }
    return nret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
notl %ebp
xorl %r15d, %r15d
cmpq 0x10(%rbx), %r12
jae 0x11d3a
movq 0x8(%rbx), %rax
testl %ebp, (%rax,%r12,4)
jne 0x11d35
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0x110c0
incl %r15d
incq %r12
jmp 0x11d13
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/buffer.c
// Function: BindBufferBase
static int BindBufferBase(lua_State *L)
    {
    GLenum target = checkbufferrangetarget(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLuint buffer = luaL_checkinteger(L, 3); 
    glBindBufferBase(target, index, buffer);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x43511(%rip), %rcx     # 0x555e8
movl %ebp, %edi
movl %r14d, %esi
movl %eax, %edx
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq