LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafAliFree
void mafAliFree(struct mafAli **pObj)
/* Free up a maf alignment. */
{
struct mafAli *obj = *pObj;
if (obj == NULL)
    return;
mafCompFreeList(&obj->components);
mafRegDefFree(&obj->regDef);
freez(pObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f390
jmp 0x3f3b3
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3f1e0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3f3c0
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafRegDefFree
void mafRegDefFree(struct mafRegDef **mrdPtr)
/* Free a mafRegDef object */
{
struct mafRegDef *mrd = *mrdPtr;
if (mrd != NULL)
    {
    freeMem(mrd->id);
    freeMem(mrd);
    *mrdPtr = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f3ff
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rdi
callq 0x40d40
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafAliFreeList
void mafAliFreeList(struct mafAli **pList)
/* Free up a list of maf alignmentx. */
{
struct mafAli *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    mafAliFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f44c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3f370
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3f427
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafFileFree
void mafFileFree(struct mafFile **pObj)
/* Free up a maf file. */
{
struct mafFile *obj = *pObj;
if (obj == NULL)
    return;
lineFileClose(&obj->lf);
freeMem(obj->scoring);
mafAliFreeList(&obj->alignments);
freez(pObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f480
jmp 0x3f4b0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3c110
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x3f410
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafFileFreeList
void mafFileFreeList(struct mafFile **pList)
/* Free up a list of maf files. */
{
struct mafFile *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    mafFileFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f4fc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3f460
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3f4d7
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindComponent
struct mafComp *mafMayFindComponent(struct mafAli *maf, char *src)
/* Find component of given source. Return NULL if not found. */
{
struct mafComp *mc;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (sameString(mc->src, src))
        return mc;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3f562
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a40
cmpl $0x0, %eax
jne 0x3f553
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f56a
jmp 0x3f555
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f52c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindComponentDb
struct mafComp *mafMayFindComponentDb(struct mafAli *maf, char *db)
/* Find component of given database, allowing component to be 
 * labeled "db", or "db.chrom" . Return NULL if not found. */
{
struct mafComp *mc;
char *p, *q;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    for (p = mc->src, q = db; *p && *q; p++, q++)
        {
        if (*p != *q)
            break;
        }
    if (*p == '.' && *q == 0)
        return mc;
    if (*p == *q)
        return mc;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3f661
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x3f5d8
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x3f5e1
jmp 0x3f611
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3f5f5
jmp 0x3f611
jmp 0x3f5f7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3f5b7
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x3f633
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3f633
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f669
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x3f64f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f669
jmp 0x3f651
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f598
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafFindComponent
struct mafComp *mafFindComponent(struct mafAli *maf, char *src)
/* Find component of given source or die trying. */
{
struct mafComp *mc = mafMayFindComponent(maf, src);
if (mc == NULL)
    errAbort("Couldn't find %s in maf", src);
return mc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f6aa
movq -0x10(%rbp), %rsi
leaq 0x9c0e5(%rip), %rdi     # 0xdb788
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindCompSpecies
struct mafComp *mafMayFindCompSpecies(struct mafAli *maf, char *species, char sepChar)
/* Find component of given source that starts with species possibly followed by sepChar or \0 .
   Return NULL if not found. */
{
struct mafComp *mc;
int speciesLen = strlen(species);

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (startsWith(species, mc->src) )
	{
	char endChar = mc->src[speciesLen];

	if ((endChar == '\0') || (endChar == sepChar))
	    return mc;
	}
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62c0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3f74c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2d3d0
cmpl $0x0, %eax
je 0x3f73d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
movsbl -0x2d(%rbp), %eax
cmpl $0x0, %eax
je 0x3f731
movsbl -0x2d(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3f73b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f754
jmp 0x3f73d
jmp 0x3f73f
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f6ed
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafFindCompSpecies
struct mafComp *mafFindCompSpecies(struct mafAli *maf, char *species, char sepChar)
/* Find component of given source that starts with species followed by sepChar
   or die trying. */
{
struct mafComp *mc = mafMayFindCompSpecies(maf, species, sepChar);
if (mc == NULL)
    errAbort("Couldn't find %s%c or just %s... in maf", species,sepChar,species);
return mc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x3f6c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3f7ab
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x9bffc(%rip), %rdi     # 0xdb7a0
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindCompPrefix
struct mafComp *mafMayFindCompPrefix(struct mafAli *maf, char *pre, char *sep)
/* Find component of given source that starts with pre followed by sep.
   Return NULL if not found. */
{
struct mafComp *mc;
char prefix[256];

if (sep == NULL)
    sep = "";
snprintf(prefix, 256, "%s%s", pre, sep);

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (startsWith(prefix, mc->src))
        return mc;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3f7e9
leaq 0xa5c21(%rip), %rax     # 0xe5406
movq %rax, -0x20(%rbp)
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x9b9f8(%rip), %rdx     # 0xdb1fc
movb $0x0, %al
callq 0x6c20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3f850
leaq -0x130(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2d3d0
cmpl $0x0, %eax
je 0x3f841
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f858
jmp 0x3f843
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f817
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafFindCompPrefix
struct mafComp *mafFindCompPrefix(struct mafAli *maf, char *pre, char *sep)
/* Find component of given source that starts with pre followed by sep
   or die trying. */
{
struct mafComp *mc = mafMayFindCompPrefix(maf, pre, sep);
if (mc == NULL)
    errAbort("Couldn't find %s%s... in maf", pre,sep);
return mc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3f7c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3f8b6
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x9bf19(%rip), %rdi     # 0xdb7c8
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindComponentInHash
struct mafComp *mafMayFindComponentInHash(struct mafAli *maf, struct hash *cHash) 
/* Find arbitrary component of given source that matches any string in the cHash.
   Return NULL if not found. */
{
struct mafComp *mc;

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (hashFindVal(cHash, mc->src))
        return mc;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3f913
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x39630
cmpq $0x0, %rax
je 0x3f904
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f91b
jmp 0x3f906
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f8dc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindSpeciesInHash
struct mafComp *mafMayFindSpeciesInHash(struct mafAli *maf, struct hash *cHash, char sepChar) 
/* Find arbitrary component of given who's source prefix (ended by sep)
   matches matches any string in the cHash.  Return NULL if not found. */
{
struct mafComp *mc;

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    char *sep = strchr(mc->src, sepChar);
    if (sep != NULL)
        *sep = '\0';
    boolean hit = hashFindVal(cHash, mc->src) != NULL;
    if (sep != NULL)
        *sep = sepChar;
    if (hit)
        return mc;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3f9ca
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movsbl -0x19(%rbp), %esi
callq 0x6260
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3f97b
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x39630
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3f9ab
movb -0x19(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
cmpl $0x0, -0x34(%rbp)
je 0x3f9bb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f9d2
jmp 0x3f9bd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f951
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafMayFindAllComponents
boolean mafMayFindAllComponents(struct mafAli *maf, struct hash *cHash) 
/* Find component of given source that starts matches any string in the cHash.
   Return NULL if not found. */
{
struct hashCookie cookie = hashFirst(cHash);
struct hashEl *el;

while ((el = hashNext(&cookie)) != NULL)
    if (mafMayFindComponent(maf, el->name) == NULL)
	return FALSE;
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x39e60
leaq -0x30(%rbp), %rdi
callq 0x39f10
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3fa32
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3f510
cmpq $0x0, %rax
jne 0x3fa30
movl $0x0, -0x4(%rbp)
jmp 0x3fa39
jmp 0x3f9fd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafNeedSubset
boolean mafNeedSubset(struct mafAli *maf, char *componentSource,
	int newStart, int newEnd)
/* Return TRUE if maf only partially fits between newStart/newEnd
 * in given component. */
{
struct mafComp *mcMaster = mafFindComponent(maf, componentSource);

/* Reverse complement input range if necessary. */
if (mcMaster->strand == '-')
    reverseIntRange(&newStart, &newEnd, mcMaster->srcSize);

return newStart > mcMaster->start || newEnd < mcMaster->start + mcMaster->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f670
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x2d, %eax
jne 0x3fe38
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x33350
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rdx
movb $0x1, %al
cmpl 0x18(%rdx), %ecx
movb %al, -0x21(%rbp)
jg 0x3fe62
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
movq -0x20(%rbp), %rdx
addl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafFlipStrand
void mafFlipStrand(struct mafAli *maf)
/* Reverse complement maf. */
{
struct mafComp *mc;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    int e = mc->start + mc->size;
    reverseIntRange(&mc->start, &e, mc->srcSize);
    if (mc->text != NULL)
        reverseComplement(mc->text, maf->textSize);
    if (mc->quality != NULL)
	reverseBytes(mc->quality, maf->textSize);
    if (mc->strand == '-')
        mc->strand = '+';
    else
        mc->strand = '-';
    char holdStatus = mc->leftStatus;
    mc->leftStatus = mc->rightStatus;
    mc->rightStatus = holdStatus;
    int holdLen = mc->leftLen;
    mc->leftLen = mc->rightLen;
    mc->rightLen = holdLen;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ff6f
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x1c(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
leaq -0x14(%rbp), %rsi
callq 0x33350
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3fedc
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
callq 0x33300
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3fefc
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
callq 0x2a560
movq -0x10(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x2d, %eax
jne 0x3ff13
movq -0x10(%rbp), %rax
movb $0x2b, 0x14(%rax)
jmp 0x3ff1b
movq -0x10(%rbp), %rax
movb $0x2d, 0x14(%rax)
movq -0x10(%rbp), %rax
movb 0x30(%rax), %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movb 0x38(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
movb -0x15(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x38(%rax)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3fe88
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafSrcDb
void mafSrcDb(char *name, char *retDb, int retDbSize)
/* Parse out just database part of name (up to but not including
 * first dot). If dot found, return entire name */
{
int len;
char *e = strchr(name, '.');
/* Put prefix up to dot into buf. */
len = (e == NULL ? strlen(name) : e - name);
if (len >= retDbSize)
     len = retDbSize-1;
memcpy(retDb, name, len);
retDb[len] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ffbb
movq -0x8(%rbp), %rdi
callq 0x62c0
movq %rax, -0x28(%rbp)
jmp 0x3ffca
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x3ffe2
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x6570
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafColumnEmpty
boolean mafColumnEmpty(struct mafAli *maf, int col)
/* Return TRUE if the column is all '-' or '.' */
{
assert(col < maf->textSize);
struct mafComp *comp;
for (comp = maf->components; comp != NULL; comp = comp->next)
    if (comp->text != NULL)
        {
        char c = comp->text[col];
        if (c != '.' && c != '-')
            return FALSE;
        }
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4002d
jmp 0x4004c
leaq 0x9b7b1(%rip), %rdi     # 0xdb7e5
leaq 0x9b7be(%rip), %rsi     # 0xdb7f9
movl $0x315, %edx            # imm = 0x315
leaq 0x9b7bc(%rip), %rcx     # 0xdb803
callq 0x6450
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x400a8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x40099
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x2e, %eax
je 0x40097
movsbl -0x21(%rbp), %eax
cmpl $0x2d, %eax
je 0x40097
movl $0x0, -0x4(%rbp)
jmp 0x400af
jmp 0x40099
jmp 0x4009b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x40058
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafStripEmptyColumns
void mafStripEmptyColumns(struct mafAli *maf)
/* Remove columns that are all '-' or '.' from  maf. */
{
/* Selectively copy over non-empty columns. */
int readIx=0, writeIx = 0;
struct mafComp *comp;
for (readIx=0; readIx < maf->textSize; ++readIx)
    {
    if (!mafColumnEmpty(maf, readIx))
        {
        for (comp = maf->components; comp != NULL; comp = comp->next) 
            {
            if(comp->text != NULL)
                comp->text[writeIx] = comp->text[readIx];
            if (comp->quality != NULL)
                comp->quality[writeIx] = comp->quality[readIx];
            }
        ++writeIx;
        }
    }
/* Zero terminate text, and update textSize. */
for (comp = maf->components; comp != NULL; comp = comp->next)
    {
    if (comp->text != NULL)
        comp->text[writeIx] = 0;
    if (comp->quality != NULL)
        comp->quality[writeIx] = 0;
    }
maf->textSize = writeIx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4018f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x40010
cmpl $0x0, %eax
jne 0x4017f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x40176
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4013e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x40167
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x40169
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4010e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x40181
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x400e1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x401e7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x401bd
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x401d8
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x401da
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4019b
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafRegDefNew
struct mafRegDef *mafRegDefNew(char *type, int size, char *id)
/* construct a new mafRegDef object */
{
struct mafRegDef *mrd;
AllocVar(mrd);
if (sameString(type, mafRegDefTxUpstream))
    mrd->type = mafRegDefTxUpstream;
else
    errAbort("invalid mafRefDef type: %s", type);
mrd->size = size;
mrd->id = cloneString(id);
return mrd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x40c50
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq 0xc6afc(%rip), %rsi     # 0x106d28
callq 0x6a40
cmpl $0x0, %eax
jne 0x40246
movq 0xc6aeb(%rip), %rcx     # 0x106d28
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x40258
movq -0x8(%rbp), %rsi
leaq 0x9b5db(%rip), %rdi     # 0xdb82c
movb $0x0, %al
callq 0x35d40
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafCompClone
struct mafComp *mafCompClone(struct mafComp *srcComp)
/* clone a mafComp */
{
struct mafComp *comp;
AllocVar(comp);
comp->src = cloneString(srcComp->src);
comp->srcSize = srcComp->srcSize;
comp->strand = srcComp->strand;
comp->start = srcComp->start;
comp->size = srcComp->size;
comp->text = cloneString(srcComp->text);
comp->quality = cloneString(srcComp->quality);
comp->leftStatus = srcComp->leftStatus;
comp->leftLen = srcComp->leftLen;
comp->rightStatus = srcComp->rightStatus;
comp->rightLen = srcComp->rightLen;
return comp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0x40c50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movb 0x14(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movb 0x30(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movb 0x38(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafAliClone
struct mafAli *mafAliClone(struct mafAli *srcAli)
/* clone a mafAli */
{
struct mafAli *ali;
AllocVar(ali);
ali->score = srcAli->score;
struct mafComp *srcComp;
for (srcComp = srcAli->components; srcComp != NULL; srcComp = srcComp->next)
    slAddHead(&ali->components, mafCompClone(srcComp));
slReverse(&ali->components);
ali->textSize = srcAli->textSize;
if (srcAli->regDef != NULL)
    ali->regDef = mafRegDefClone(srcAli->regDef);
return ali;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x40c50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x403fd
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x402b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3eb80
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x403c8
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x2aad0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4043b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x40450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/mafFromAxt.c
// Function: mafFromAxtTemp
void mafFromAxtTemp(struct axt *axt, int tSize, int qSize,
	struct mafAli *temp)
/* Make a maf out of axt,  parasiting on the memory in axt.
 * Do *not* mafFree this temp.  The memory it has in pointers
 * is still owned by the axt.  Furthermore the next call to
 * this function will invalidate the previous temp value.
 * It's sort of a kludge, but quick to run and easy to implement. */
{
static struct mafComp qComp, tComp;
ZeroVar(temp);
ZeroVar(&qComp);
ZeroVar(&tComp);
temp->score = axt->score;
temp->textSize = axt->symCount;
qComp.src = axt->qName;
qComp.srcSize = qSize;
qComp.strand = axt->qStrand;
qComp.start = axt->qStart;
qComp.size = axt->qEnd - axt->qStart;
qComp.text = axt->qSym;
slAddHead(&temp->components, &qComp);
tComp.src = axt->tName;
tComp.srcSize = tSize;
tComp.strand = axt->tStrand;
tComp.start = axt->tStart;
tComp.size = axt->tEnd - axt->tStart;
tComp.text = axt->tSym;
slAddHead(&temp->components, &tComp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x405c0
leaq 0xc95ad(%rip), %rdi     # 0x109a58
movl $0x40, %esi
callq 0x405c0
leaq 0xc95dc(%rip), %rdi     # 0x109a98
movl $0x40, %esi
callq 0x405c0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x34(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc956b(%rip)     # 0x109a60
movl -0x10(%rbp), %eax
movl %eax, 0xc956a(%rip)     # 0x109a68
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
movb %al, 0xc9561(%rip)      # 0x109a6c
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc9558(%rip)     # 0x109a70
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, 0xc9548(%rip)     # 0x109a74
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, 0xc953d(%rip)     # 0x109a78
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0xc950e(%rip), %rsi     # 0x109a58
callq 0x405f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0xc9542(%rip)     # 0x109aa0
movl -0xc(%rbp), %eax
movl %eax, 0xc9541(%rip)     # 0x109aa8
movq -0x8(%rbp), %rax
movb 0x30(%rax), %al
movb %al, 0xc9538(%rip)      # 0x109aac
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, 0xc952f(%rip)     # 0x109ab0
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x28(%rcx), %eax
movl %eax, 0xc951f(%rip)     # 0x109ab4
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, 0xc9514(%rip)     # 0x109ab8
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0xc94e5(%rip), %rsi     # 0x109a98
callq 0x405f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/memalloc.c
// Function: carefulCountBlocksAllocated
int carefulCountBlocksAllocated()
/* How many memory items are allocated? */
{
pthread_mutex_lock( &carefulMutex );
int result = dlCount(cmbAllocedList);
pthread_mutex_unlock( &carefulMutex );
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc8b71(%rip), %rdi     # 0x109ae0
callq 0x6ae0
movq 0xc8b8d(%rip), %rdi     # 0x109b08
callq 0x32360
movl %eax, -0x4(%rbp)
leaq 0xc8b56(%rip), %rdi     # 0x109ae0
callq 0x64e0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/memalloc.c
// Function: carefulTotalAllocated
size_t carefulTotalAllocated()
/* Return total bases allocated */
{
pthread_mutex_lock( &carefulMutex );
size_t result = carefulAlloced;
pthread_mutex_unlock( &carefulMutex );
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc8b31(%rip), %rdi     # 0x109ae0
callq 0x6ae0
movq 0xc8b55(%rip), %rax     # 0x109b10
movq %rax, -0x8(%rbp)
leaq 0xc8b1a(%rip), %rdi     # 0x109ae0
callq 0x64e0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/memalloc.c
// Function: carefulFree
static void carefulFree(void *vpt)
/* Check cookies and free. */
{
pthread_mutex_lock( &carefulMutex );
struct carefulMemBlock *cmb = ((struct carefulMemBlock *)vpt)-1;
size_t size = cmb->size;
char *pEndCookie;

carefulAlloced -= size;
pEndCookie = (((char *)(cmb+1)) + size);
if (cmb->startCookie != cmbStartCookie)
    {
    pthread_mutex_unlock( &carefulMutex );
    errAbort("Bad start cookie %x freeing %llx\n", cmb->startCookie,
             ptrToLL(vpt));
    }
if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
    {
    pthread_mutex_unlock( &carefulMutex );
    errAbort("Bad end cookie %x%x%x%x freeing %llx\n", 
        pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
             ptrToLL(vpt));
    }
dlRemove((struct dlNode *)cmb);
carefulParent->free(cmb);
pthread_mutex_unlock( &carefulMutex );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc85cd(%rip), %rdi     # 0x109ae0
callq 0x6ae0
movq -0x8(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0xc85d5(%rip), %rax     # 0x109b10
subq %rcx, %rax
movq %rax, 0xc85cb(%rip)     # 0x109b10
movq -0x10(%rbp), %rax
addq $0x18, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl 0xc57fe(%rip), %eax     # 0x106d60
je 0x41589
leaq 0xc8575(%rip), %rdi     # 0x109ae0
callq 0x64e0
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x8(%rbp), %rdx
leaq 0x9a64b(%rip), %rdi     # 0xdbbcd
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl 0xc57cf(%rip), %ecx     # 0x106d64
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x415e0
leaq 0xc8537(%rip), %rdi     # 0x109ae0
callq 0x64e0
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %edx
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %ecx
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %r8d
movq -0x8(%rbp), %r9
leaq 0x9a616(%rip), %rdi     # 0xdbbef
movb $0x0, %al
callq 0x35d40
movq -0x10(%rbp), %rdi
callq 0x321f0
movq 0xc84e8(%rip), %rax     # 0x109ad8
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
leaq 0xc84df(%rip), %rdi     # 0x109ae0
callq 0x64e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: setReadWriteTimeouts
int setReadWriteTimeouts(int sd, int seconds)
/* Set read and write timeouts on socket sd 
 * Return -1 if there are any errors, 0 if successful. */
{
struct timeval timeout;      
timeout.tv_sec = seconds;
timeout.tv_usec = 0;

if (setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
    {
    warn("setsockopt failed setting socket receive timeout\n");
    return -1;
    }

if (setsockopt(sd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
    {
    warn("setsockopt failed setting socket send timeout\n");
    return -1;
    }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq -0x20(%rbp), %rcx
movl $0x10, %r8d
callq 0x6d80
cmpl $0x0, %eax
jge 0x416c6
leaq 0x9a55f(%rip), %rdi     # 0xdbc15
movb $0x0, %al
callq 0x358e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x41705
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x15, %edx
leaq -0x20(%rbp), %rcx
movl $0x10, %r8d
callq 0x6d80
cmpl $0x0, %eax
jge 0x416fe
leaq 0x9a559(%rip), %rdi     # 0xdbc47
movb $0x0, %al
callq 0x358e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x41705
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netMustConnect
int netMustConnect(char *hostName, int port)
/* Start connection with server or die. */
{
int sd = netConnect(hostName, port);
if (sd < 0)
   noWarnAbort();
return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x41710
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x41c0b
movb $0x0, %al
callq 0x35e40
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netAcceptingSocketFrom
int netAcceptingSocketFrom(int port, int queueSize, char *host)
/* Create a socket that can accept connections from a 
 * IP address on the current machine if the current machine
 * has multiple IP addresses. */
{
struct sockaddr_in sai;
int sd;
int flag = 1;

netBlockBrokenPipes();
if ((sd = netStreamSocket()) < 0)
    return sd;
if (!internetFillInAddress(host, port, &sai))
    return -1;
if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int)))
    return -1;
if (bind(sd, (struct sockaddr*)&sai, sizeof(sai)) == -1)
    {
    warn("Couldn't bind socket to %d: %s", port, strerror(errno));
    close(sd);
    return -1;
    }
listen(sd, queueSize);
return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x30(%rbp)
callq 0x41f10
callq 0x45dc0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x41cc6
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41d77
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x6c410
cmpl $0x0, %eax
jne 0x41ce7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x41d77
movl -0x2c(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x30(%rbp), %rcx
movl $0x4, %r8d
callq 0x6d80
cmpl $0x0, %eax
je 0x41d11
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x41d77
movl -0x2c(%rbp), %edi
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x10, %edx
callq 0x6140
cmpl $-0x1, %eax
jne 0x41d66
movl -0x8(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x6060
movl (%rax), %edi
callq 0x6220
movl -0x3c(%rbp), %esi
movq %rax, %rdx
leaq 0x99f56(%rip), %rdi     # 0xdbca4
movb $0x0, %al
callq 0x358e0
movl -0x2c(%rbp), %edi
callq 0x6e90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x41d77
movl -0x2c(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x6800
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netAcceptFrom
int netAcceptFrom(int acceptor, unsigned char subnet[4])
/* Wait for incoming connection from socket descriptor
 * from IP address in subnet.  Subnet is something
 * returned from netParseSubnet or internetParseDottedQuad. 
 * Subnet may be NULL. */
{
struct sockaddr_in sai;		/* Some system socket info. */
ZeroVar(&sai);
sai.sin_family = AF_INET;
for (;;)
    {
    socklen_t addrSize = sizeof(sai);
    int sd = accept(acceptor, (struct sockaddr *)&sai, &addrSize);
    if (sd >= 0)
	{
	if (subnet == NULL)
	    return sd;
	else
	    {
	    unsigned char unpacked[4]; 
	    internetUnpackIp(ntohl(sai.sin_addr.s_addr), unpacked);
	    if (internetIpInSubnet(unpacked, subnet))
		{
		return sd;
		}
	    else
		{
		close(sd);
		}
	    }
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x41e80
movw $0x2, -0x20(%rbp)
movl $0x10, -0x24(%rbp)
movl -0x8(%rbp), %edi
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x61e0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x41e73
cmpq $0x0, -0x10(%rbp)
jne 0x41e3a
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41e75
movl -0x1c(%rbp), %edi
callq 0x6970
movl %eax, %edi
leaq -0x34(%rbp), %rsi
callq 0x6c5d0
leaq -0x34(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c620
cmpl $0x0, %eax
je 0x41e67
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41e75
movl -0x28(%rbp), %edi
callq 0x6e90
jmp 0x41e71
jmp 0x41e73
jmp 0x41e03
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netFileFromSocket
FILE *netFileFromSocket(int socket)
/* Wrap a FILE around socket.  This should be fclose'd
 * and separately the socket close'd. */
{
FILE *f;
if ((socket = dup(socket)) < 0)
   errnoAbort("Couldn't dupe socket in netFileFromSocket");
f = fdopen(socket, "r+");
if (f == NULL)
   errnoAbort("Couldn't fdopen socket in netFileFromSocket");
return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x6b60
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jge 0x41ed9
leaq 0x99df1(%rip), %rdi     # 0xdbcc3
movb $0x0, %al
callq 0x35ee0
movl -0x4(%rbp), %edi
leaq 0x99e0a(%rip), %rsi     # 0xdbced
callq 0x6750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41f01
leaq 0x99df6(%rip), %rdi     # 0xdbcf0
movb $0x0, %al
callq 0x35ee0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netReadAll
ssize_t netReadAll(int sd, void *vBuf, ssize_t size)
/* Read given number of bytes into buffer.
 * Don't give up on first read! */
{
char *buf = vBuf;
ssize_t totalRead = 0;
int oneRead;

if (!plumberInstalled)
    netBlockBrokenPipes();
while (totalRead < size)
    {
    oneRead = read(sd, buf + totalRead, size - totalRead);
    if (oneRead < 0)
	return oneRead;
    if (oneRead == 0)
        break;
    totalRead += oneRead;
    }
return totalRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x0, 0xc7bd6(%rip)     # 0x109b40
jne 0x41f71
callq 0x41f10
jmp 0x41f73
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x41fbe
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x6a90
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x41fa8
movslq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x41fc6
cmpl $0x0, -0x34(%rbp)
jne 0x41fb0
jmp 0x41fbe
movslq -0x34(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x41f73
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netMustReadAll
ssize_t netMustReadAll(int sd, void *vBuf, ssize_t size)
/* Read given number of bytes into buffer or die.
 * Don't give up if first read is short! */
{
ssize_t ret = netReadAll(sd, vBuf, size);
if (ret < 0)
    errnoAbort("Couldn't finish netReadAll");
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x41f40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x4200c
leaq 0x99d17(%rip), %rdi     # 0xdbd1c
movb $0x0, %al
callq 0x35ee0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netParseSubnet
void netParseSubnet(char *in, unsigned char out[4])
/* Parse subnet, which is a prefix of a normal dotted quad form.
 * Out will contain 255's for the don't care bits. */
{
out[0] = out[1] = out[2] = out[3] = 255;
if (in != NULL)
    {
    char *snsCopy = strdup(in);
    char *words[5];
    int wordCount, i;
    wordCount = chopString(snsCopy, ".", words, ArraySize(words));
    if (wordCount > 3 || wordCount < 1)
        notGoodSubnet(in);
    for (i=0; i<wordCount; ++i)
	{
	char *s = words[i];
	int x;
	if (!isdigit(s[0]))
	    notGoodSubnet(in);
	x = atoi(s);
	if (x > 255)
	    notGoodSubnet(in);
	out[i] = x;
	}
    freez(&snsCopy);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $-0x1, 0x3(%rax)
movq -0x10(%rbp), %rax
movb $-0x1, 0x2(%rax)
movq -0x10(%rbp), %rax
movb $-0x1, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $-0x1, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x4211f
movq -0x8(%rbp), %rdi
callq 0x6dd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq 0x9868a(%rip), %rsi     # 0xda700
movl $0x5, %ecx
callq 0x2e840
movl %eax, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jg 0x4208f
cmpl $0x1, -0x44(%rbp)
jge 0x42098
movq -0x8(%rbp), %rdi
callq 0x42130
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x42116
movslq -0x48(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movq %rax, -0x50(%rbp)
callq 0x6780
movq (%rax), %rax
movq -0x50(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x420dd
movq -0x8(%rbp), %rdi
callq 0x42130
movq -0x50(%rbp), %rdi
callq 0x6bd0
movl %eax, -0x54(%rbp)
cmpl $0xff, -0x54(%rbp)
jle 0x420fb
movq -0x8(%rbp), %rdi
callq 0x42130
movl -0x54(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4209f
leaq -0x18(%rbp), %rdi
callq 0x40d70
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: parseByteRange
static void parseByteRange(char *url, ssize_t *rangeStart, ssize_t *rangeEnd, boolean terminateAtByteRange)
/* parse the byte range information from url */
{
char *x;
/* default to no byte range specified */
*rangeStart = -1;
*rangeEnd = -1;
x = strrchr(url, ';');
if (x)
    {
    if (startsWith(";byterange=", x))
	{
	char *y=strchr(x, '=');
	++y;
	char *z=strchr(y, '-');
	if (z)
	    {
	    ++z;
	    if (terminateAtByteRange)
		*x = 0;
	    // TODO: use something better than atoll() ?
	    *rangeStart = atoll(y); 
	    if (z[0] != '\0')
		*rangeEnd = atoll(z);
	    }    
	}
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq $-0x1, (%rax)
movq -0x18(%rbp), %rax
movq $-0x1, (%rax)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x67b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4275b
movq -0x28(%rbp), %rsi
leaq 0x9979b(%rip), %rdi     # 0xdbe60
callq 0x2d3d0
cmpl $0x0, %eax
je 0x42759
movq -0x28(%rbp), %rdi
movl $0x3d, %esi
callq 0x6260
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x2d, %esi
callq 0x6260
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x42757
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x42723
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rdi
callq 0x6520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x42755
movq -0x38(%rbp), %rdi
callq 0x6520
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x42757
jmp 0x42759
jmp 0x4275b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)