LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binFromRangeStandard
static int binFromRangeStandard(int start, int end)
/* Given start,end in chromosome coordinates assign it
 * a bin.   There's a bin for each 128k segment, for each
 * 1M segment, for each 8M segment, for each 64M segment,
 * and for each chromosome (which is assumed to be less than
 * 512M.)  A range goes into the smallest bin it will fit in. */
{
int startBin = start, endBin = end-1, i;
startBin >>= _binFirstShift;
endBin >>= _binFirstShift;
for (i=0; i<ArraySize(binOffsets); ++i)
    {
    if (startBin == endBin)
        return binOffsets[i] + startBin;
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
errAbort("start %d, end %d out of range in findBin (max is 512M)", start, end);
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x5, %rax
jae 0x249eb
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x249ce
movslq -0x18(%rbp), %rcx
leaq 0xe1d5d(%rip), %rax     # 0x106720
movl (%rax,%rcx,4), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x24a06
movl -0x10(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x249a6
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xb41d0(%rip), %rdi     # 0xd8bc8
movb $0x0, %al
callq 0x35d40
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/binRange.c
// Function: binFromRangeExtended
static int binFromRangeExtended(int start, int end)
/* Given start,end in chromosome coordinates assign it
 * a bin.   There's a bin for each 128k segment, for each
 * 1M segment, for each 8M segment, for each 64M segment,
 * for each 512M segment, and one top level bin for 4Gb.
 *	Note, since start and end are int's, the practical limit
 *	is up to 2Gb-1, and thus, only four result bins on the second
 *	level.
 * A range goes into the smallest bin it will fit in. */
{
int startBin = start, endBin = end-1, i;
startBin >>= _binFirstShift;
endBin >>= _binFirstShift;
for (i=0; i<ArraySize(binOffsetsExtended); ++i)
    {
    if (startBin == endBin)
	return _binOffsetOldToExtended + binOffsetsExtended[i] + startBin;
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
errAbort("start %d, end %d out of range in findBin (max is 2Gb)", start, end);
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x6, %rax
jae 0x24a90
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x24a73
movslq -0x18(%rbp), %rcx
leaq 0xe1c9d(%rip), %rax     # 0x106700
movl (%rax,%rcx,4), %eax
addl $0x1249, %eax           # imm = 0x1249
addl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x24aab
movl -0x10(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x24a46
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xb4162(%rip), %rdi     # 0xd8bff
movb $0x0, %al
callq 0x35d40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperNew
struct binKeeper *binKeeperNew(int minPos, int maxPos)
/* Create new binKeeper that can cover range. */
{
int binCount;
struct binKeeper *bk;
if (minPos < 0 || maxPos < 0 || minPos > maxPos)
    errAbort("bad range %d,%d in binKeeperNew", minPos, maxPos);

binCount = binFromRangeBinKeeperExtended(maxPos-1, maxPos) + 1;
AllocVar(bk);
bk->minPos = minPos;
bk->maxPos = maxPos;
bk->binCount = binCount;
AllocArray(bk->binLists, binCount);
return bk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x24ae2
cmpl $0x0, -0x8(%rbp)
jl 0x24ae2
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x24af6
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0xb4041(%rip), %rdi     # 0xd8b30
movb $0x0, %al
callq 0x35d40
movl -0x8(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
callq 0x24b60
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x20, %edi
callq 0x40c50
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binFromRangeBinKeeperExtended
static int binFromRangeBinKeeperExtended(int start, int end)
/* This is just like binFromRangeExtended() above, but it doesn't limit
 * the answers to the range from _binOffsetOldToExtended and up.
 *	It simply uses the whole new bin scheme as if it was the only
 *	one.
 */
{
int startBin = start, endBin = end-1, i;
startBin >>= _binFirstShift;
endBin >>= _binFirstShift;
for (i=0; i<ArraySize(binOffsetsExtended); ++i)
    {
    if (startBin == endBin)
	return binOffsetsExtended[i] + startBin;
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
errAbort("start %d, end %d out of range in findBin (max is 2Gb)", start, end);
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x6, %rax
jae 0x24bdb
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x24bbe
movslq -0x18(%rbp), %rcx
leaq 0xe1b4d(%rip), %rax     # 0x106700
movl (%rax,%rcx,4), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x24bf6
movl -0x10(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x24b96
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xb4017(%rip), %rdi     # 0xd8bff
movb $0x0, %al
callq 0x35d40
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/binRange.c
// Function: binKeeperFree
void binKeeperFree(struct binKeeper **pBk)
/* Free up a bin keeper. */
{
struct binKeeper *bk = *pBk;
if (bk != NULL)
    {
    int i;
    for (i=0; i<bk->binCount; ++i)
	slFreeList(&bk->binLists[i]);
    freeMem(bk->binLists);
    freez(pBk);
    }
}

// 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 0x24c6a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x24c54
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x2ab30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x24c25
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x40d40
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperAdd
void binKeeperAdd(struct binKeeper *bk, int start, int end, void *val)
/* Add item to binKeeper. */ 
{
int bin;
struct binElement *el;
if (start < bk->minPos || end > bk->maxPos || start > end)
    errAbort("(%d %d) out of range (%d %d) in binKeeperAdd", 
    	start, end, bk->minPos, bk->maxPos);
bin = binFromRangeBinKeeperExtended(start, end);
assert(bin < bk->binCount);
AllocVar(el);
el->start = start;
el->end = end;
el->val = val;
slAddHead(&bk->binLists[bin], el);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x24ca6
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x24ca6
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x24cc9
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %r8d
leaq 0xb3e8e(%rip), %rdi     # 0xd8b50
movb $0x0, %al
callq 0x35d40
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x24b60
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x24ce5
jmp 0x24d04
leaq 0xb3e91(%rip), %rdi     # 0xd8b7d
leaq 0xb3dd4(%rip), %rsi     # 0xd8ac7
movl $0xb4, %edx
leaq 0xb3e91(%rip), %rcx     # 0xd8b90
callq 0x6450
movl $0x18, %edi
callq 0x40c50
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x24d60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperFind
struct binElement *binKeeperFind(struct binKeeper *bk, int start, int end)
/* Return a list of all items in binKeeper that intersect range.
 * Free this list with slFreeList. */
{
struct binElement *list = NULL, *newEl, *el;
int startBin, endBin;
int i,j;

if (start < bk->minPos) start = bk->minPos;
if (end > bk->maxPos) end = bk->maxPos;
if (start >= end) return NULL;
startBin = (start>>_binFirstShift);
endBin = ((end-1)>>_binFirstShift);
for (i=0; i<ArraySize(binOffsetsExtended); ++i)
    {
    int offset = binOffsetsExtended[i];
    for (j=startBin+offset; j<=endBin+offset; ++j)
        {
	for (el=bk->binLists[j]; el != NULL; el = el->next)
	    {
	    if (rangeIntersection(el->start, el->end, start, end) > 0)
	        {
		newEl = CloneVar(el);
		slAddHead(&list, newEl);
		}
	    }
	}
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x24e10
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x24e26
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x24e3b
movq $0x0, -0x8(%rbp)
jmp 0x24f2b
movl -0x14(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x34(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
sarl $0x11, %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movslq -0x3c(%rbp), %rax
cmpq $0x6, %rax
jae 0x24f23
movslq -0x3c(%rbp), %rcx
leaq 0xe1890(%rip), %rax     # 0x106700
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
cmpl %ecx, %eax
jg 0x24f03
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x24ef3
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x305c0
cmpl $0x0, %eax
jle 0x24ee4
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x2a360
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x24d60
jmp 0x24ee6
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x24ea0
jmp 0x24ef5
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x24e7f
movl -0x34(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x24e57
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperAnyOverlap
boolean binKeeperAnyOverlap(struct binKeeper *bk, int start, int end)
/* Return TRUE if start/end overlaps with any items in binKeeper. */
{
struct binElement *el;
int startBin, endBin;
int i,j;

if (start < bk->minPos) start = bk->minPos;
if (end > bk->maxPos) end = bk->maxPos;
if (start >= end) return FALSE;
startBin = (start>>_binFirstShift);
endBin = ((end-1)>>_binFirstShift);
for (i=0; i<ArraySize(binOffsetsExtended); ++i)
    {
    int offset = binOffsetsExtended[i];
    for (j=startBin+offset; j<=endBin+offset; ++j)
        {
	for (el=bk->binLists[j]; el != NULL; el = el->next)
	    {
	    if (rangeIntersection(el->start, el->end, start, end) > 0)
	        {
		return TRUE;
		}
	    }
	}
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x24f68
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x24f7e
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x24f92
movl $0x0, -0x4(%rbp)
jmp 0x25068
movl -0x14(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
sarl $0x11, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq $0x6, %rax
jae 0x25061
movslq -0x2c(%rbp), %rcx
leaq 0xe1739(%rip), %rax     # 0x106700
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x28(%rbp), %ecx
addl -0x34(%rbp), %ecx
cmpl %ecx, %eax
jg 0x25041
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x25034
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x305c0
cmpl $0x0, %eax
jle 0x25025
movl $0x1, -0x4(%rbp)
jmp 0x25068
jmp 0x25027
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x24ff7
jmp 0x25036
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x24fd6
movl -0x24(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x24fae
movl $0x0, -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/binRange.c
// Function: binKeeperReplaceVal
void binKeeperReplaceVal(struct binKeeper *bk, int start, int end,
	void *oldVal, void *newVal)
/* Replace occurences of old val in range from start->end with newVal */
{
struct binElement *el;
int startBin, endBin;
int i,j;

if (start < bk->minPos) start = bk->minPos;
if (end > bk->maxPos) end = bk->maxPos;
if (start >= end) return;
startBin = (start>>_binFirstShift);
endBin = ((end-1)>>_binFirstShift);
for (i=0; i<ArraySize(binOffsetsExtended); ++i)
    {
    int offset = binOffsetsExtended[i];
    for (j=startBin+offset; j<=endBin+offset; ++j)
        {
	for (el=bk->binLists[j]; el != NULL; el = el->next)
	    {
	    if (rangeIntersection(el->start, el->end, start, end) > 0)
	        {
		if (el->val == oldVal)
		    {
		    el->val = newVal;
		    }
		}
	    }
	}
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x250b0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x250c6
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x250d3
jmp 0x251b5
movl -0xc(%rbp), %eax
sarl $0x11, %eax
movl %eax, -0x2c(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
sarl $0x11, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq $0x6, %rax
jae 0x251b5
movslq -0x34(%rbp), %rcx
leaq 0xe15f8(%rip), %rax     # 0x106700
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x2c(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
cmpl %ecx, %eax
jg 0x25195
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x25188
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x28(%rbp), %rax
movl 0xc(%rax), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x305c0
cmpl $0x0, %eax
jle 0x25179
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x25177
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x25179
jmp 0x2517b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x25138
jmp 0x2518a
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x25117
movl -0x2c(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x250ef
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperRemove
void binKeeperRemove(struct binKeeper *bk, int start, int end, void *val)
/* Remove item from binKeeper. */ 
{
int bin = binFromRangeBinKeeperExtended(start, end);
struct binElement **pList = &bk->binLists[bin], *newList = NULL, *el, *next;
for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    if (el->val == val && el->start == start && el->end == end)
        {
	freeMem(el);
	}
    else
        {
	slAddHead(&newList, el);
	}
    }
slReverse(&newList);
*pList = newList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x24b60
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2543a
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x25421
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x25421
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x25421
movq -0x38(%rbp), %rdi
callq 0x40d40
jmp 0x2542e
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x24d60
jmp 0x25430
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x253de
leaq -0x30(%rbp), %rdi
callq 0x2aad0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperFirst
struct binKeeperCookie binKeeperFirst(struct binKeeper *bk)
/* Return an object to use by binKeeperNext() to traverse the binElements.
 * The first call to binKeeperNext() will return the first entry in the
 * table. */
{
struct binKeeperCookie cookie;
cookie.bk = bk;
cookie.blIdx = 0;
cookie.nextBel = bk->binLists[0];
return cookie;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, (%rdi)
movl $0x0, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, 0x10(%rdi)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/binRange.c
// Function: binKeeperNext
struct binElement* binKeeperNext(struct binKeeperCookie *cookie)
/* Return the next entry in the binKeeper table.  */
{
/* if we don't have a next, move down bin list until we find one */
while ((cookie->nextBel == NULL)
       && (++cookie->blIdx < cookie->bk->binCount))
    cookie->nextBel = cookie->bk->binLists[cookie->blIdx];
if (cookie->blIdx >= cookie->bk->binCount)
    return NULL;  /* no more */
else
    {
    struct binElement* bel = cookie->nextBel;
    cookie->nextBel = cookie->nextBel->next;
    return bel;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x19(%rbp)
jne 0x254c5
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x254ce
jmp 0x254ef
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x25498
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jl 0x2550c
movq $0x0, -0x8(%rbp)
jmp 0x25533
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: progType
static char *progType(boolean isProt, struct axtBundle *ab, boolean isUpper)
/* Return blast 'program' */
{
if (!isProt)
    return isUpper ? "BLASTN" : "blastn";
else
    {
    if (ab->axtList->frame != 0)
        return isUpper ? "TBLASTN" : "tblastn";
    else
        return isUpper ? "BLASTP" : "blastp";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x26f42
movl -0x1c(%rbp), %edx
leaq 0xb2185(%rip), %rax     # 0xd90b3
leaq 0xb2176(%rip), %rcx     # 0xd90ab
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x26f8a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x50(%rax)
je 0x26f6e
movl -0x1c(%rbp), %edx
leaq 0xb2158(%rip), %rax     # 0xd90b2
leaq 0xb2149(%rip), %rcx     # 0xd90aa
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x26f8a
movl -0x1c(%rbp), %edx
leaq 0xb2149(%rip), %rax     # 0xd90c1
leaq 0xb213b(%rip), %rcx     # 0xd90ba
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: bundleIntoTargets
static struct targetHits *bundleIntoTargets(struct axtBundle *abList)
/* BLAST typically outputs everything on the same query and target
 * in one clump.  This routine rearranges axts in abList to do this. */
{
struct targetHits *targetList = NULL, *target;
struct hash *targetHash = newHash(10);
struct axtBundle *ab;
struct axtRef *ref;

/* Build up a list of targets in database hit by query sorted by
 * score of hits. */
for (ab = abList; ab != NULL; ab = ab->next)
    {
    struct axt *axt;
    for (axt = ab->axtList; axt != NULL; axt = axt->next)
	{
	target = hashFindVal(targetHash, axt->tName);
	if (target == NULL)
	    {
	    AllocVar(target);
	    slAddHead(&targetList, target);
	    hashAdd(targetHash, axt->tName, target);
	    target->name = cloneString(axt->tName);
	    target->size = ab->tSize;
	    }
	if (axt->score > target->score)
	    target->score = axt->score;
	AllocVar(ref);
	ref->axt = axt;
	slAddHead(&target->axtList, ref);
	}
    }
slSort(&targetList, targetHitsCmpScore);
for (target = targetList; target != NULL; target = target->next)
    slSort(&target->axtList, axtRefCmpScore);

hashFree(&targetHash);
return targetList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0xa, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x270be
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x270ac
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x39630
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27053
movl $0x28, %edi
callq 0x40c50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x27740
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x39230
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x27071
movq -0x38(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x10, %edi
callq 0x40c50
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
callq 0x27740
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x26fd6
jmp 0x270ae
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x26fbf
leaq -0x10(%rbp), %rdi
leaq 0x6b7(%rip), %rsi       # 0x27780
callq 0x2ab90
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x270fe
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x6d4(%rip), %rsi       # 0x277c0
callq 0x2ab90
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x270d6
leaq -0x20(%rbp), %rdi
callq 0x3a080
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: countMatches
static int countMatches(char *a, char *b, int size)
/* Count number of characters that match between a and b. */
{
int count = 0;
int i;
for (i=0; i<size; ++i)
    if (toupper(a[i]) == toupper(b[i]))
        ++count;
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x272ad
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6de0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6de0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jne 0x272a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x272a2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27261
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: countPositives
static int countPositives(char *a, char *b, int size)
/* Count positive (not necessarily identical) protein matches. */
{
int count = 0;
int i;
struct axtScoreScheme *ss = axtScoreSchemeProteinDefault();
for (i=0; i<size; ++i)
    {
    if (ss->matrix[(int)a[i]][(int)b[i]] > 0)
        ++count;
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x0, %al
callq 0x22580
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2733d
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x27330
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27332
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x272ec
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: blastzScoreToWuBits
static double blastzScoreToWuBits(int bzScore, boolean isProt)
/* Convert from blastz score to bit score.  The magic number's
 * here are taken from comparing wu-blast scores to axtScores on
 * a couple of sequences.  This doesn't really seem to be a bit
 * score.  It's not very close to 2 bits per base. */
{
int wuScore = blastzToWublastScore(bzScore);
if (isProt)
    return wuScore * 0.3545;
else
    return wuScore * 0.1553;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x271e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x27387
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0xb18dc(%rip), %xmm1    # 0xd8c58
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2739d
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0xb18bc(%rip), %xmm1    # 0xd8c50
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: targetHitsFreeList
static void targetHitsFreeList(struct targetHits **pList)
/* Free a list of dynamically allocated targetHits's */
{
struct targetHits *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    targetHitsFree(&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 0x2772c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x278f0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x27707
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/blastOut.c
// Function: calcDigitCount
static int calcDigitCount(struct axt *axt, int tSize, int qSize)
/* Figure out how many digits needed for blast position display. */
{
int tDig, qDig;
if (axt->qStrand == '-')
    qDig = digitsBaseTen(qSize - axt->qStart + 1);
else
    qDig = digitsBaseTen(axt->qEnd);
if (axt->tStrand == '-')
    tDig = digitsBaseTen(tSize - axt->tStart + 1);
else
    tDig = digitsBaseTen(axt->tEnd);
return max(tDig, qDig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x2d, %eax
jne 0x27836
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rax
subl 0x10(%rax), %edi
addl $0x1, %edi
callq 0x47630
movl %eax, -0x18(%rbp)
jmp 0x27845
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x47630
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x2d, %eax
jne 0x27869
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
subl 0x28(%rax), %edi
addl $0x1, %edi
callq 0x47630
movl %eax, -0x14(%rbp)
jmp 0x27878
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edi
callq 0x47630
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x27888
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2788e
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: plusStrandPos
static int plusStrandPos(int pos, int size, char strand, boolean isEnd)
/* Return position on plus strand, one based. */
{
if (strand == '-')
    {
    pos = size - pos;
    if (isEnd)
       ++pos;
    }
else
    {
    if (!isEnd)
        ++pos;
    }
return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %ecx, -0x10(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x2d, %eax
jne 0x278d5
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x278d3
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x278e6
cmpl $0x0, -0x10(%rbp)
jne 0x278e4
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x278e6
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: targetHitsFree
static void targetHitsFree(struct targetHits **pObj)
/* Free one target hits structure. */
{
struct targetHits *obj = *pObj;
if (obj != NULL)
    {
    freeMem(obj->name);
    slFreeList(&obj->axtList);
    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)
je 0x27931
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x2ab30
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: ncbiPrintE
static void ncbiPrintE(FILE *f, double e)
/* Print a small number NCBI style. */
{
if (e <= 0.0)
    fprintf(f, "0.0");
else if (e <= 1.0e-100)
    {
    char buf[256], *s;
    safef(buf, sizeof(buf), "%e", e);
    s = strchr(buf, 'e');
    if (s == NULL)
	fprintf(f, "0.0");
    else
        fprintf(f, "%s", s);
    }
else
    fprintf(f, "%1.0e", e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jb 0x27a55
movq -0x8(%rbp), %rdi
leaq 0xb1e97(%rip), %rsi     # 0xd98e0
movb $0x0, %al
callq 0x6a80
jmp 0x27aed
movsd 0xb121b(%rip), %xmm0    # 0xd8c78
ucomisd -0x10(%rbp), %xmm0
jb 0x27ad4
leaq -0x110(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movl $0x100, %esi            # imm = 0x100
leaq 0xb1e68(%rip), %rdx     # 0xd98e4
movb $0x1, %al
callq 0x31090
leaq -0x110(%rbp), %rdi
movl $0x65, %esi
callq 0x6260
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
jne 0x27ab9
movq -0x8(%rbp), %rdi
leaq 0xb1e30(%rip), %rsi     # 0xd98e0
movb $0x0, %al
callq 0x6a80
jmp 0x27ad2
movq -0x8(%rbp), %rdi
movq -0x118(%rbp), %rdx
leaq 0xb2546(%rip), %rsi     # 0xda011
movb $0x0, %al
callq 0x6a80
jmp 0x27aeb
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
leaq 0xb1e03(%rip), %rsi     # 0xd98e7
movb $0x1, %al
callq 0x6a80
jmp 0x27aed
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: countGaps
static int countGaps(char *a, char *b, int size)
/* Count number of inserts in either strand. */
{
int count = 0;
int i;
for (i=0; i<size; ++i)
   {
   if (a[i] == '-')
       ++count;
   if (b[i] == '-')
       ++count;
   }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x27b66
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x27b3f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x27b59
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27b5b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27b1d
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: countGapOpens
static int countGapOpens(char *a, char *b, int size)
/* Count number of inserts in either strand. */
{
int i, count = 0;
boolean inGap = FALSE;
for (i=0; i<size; ++i)
    {
    if (a[i] == '-' || b[i] == '-')
        {
	if (!inGap)
	    {
	    ++count;
	    inGap = TRUE;
	    }
	}
    else
        {
	inGap = FALSE;
	}
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x27bea
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x27bbe
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x27bd6
cmpl $0x0, -0x20(%rbp)
jne 0x27bd4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x27bdd
movl $0x0, -0x20(%rbp)
jmp 0x27bdf
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27b94
movl -0x1c(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/blastOut.c
// Function: printAxtTargetBlastTab
static void printAxtTargetBlastTab(FILE *f, struct axt *axt, int targetSize)
/* Print out target in tabular blast-oriented format. */
{
int s = axt->tStart, e = axt->tEnd;
if (axt->tStrand == '-')
    reverseIntRange(&s, &e, targetSize);
if (axt->tStrand == axt->qStrand)
    {
    fprintf(f, "%d\t", s+1);
    fprintf(f, "%d\t", e);
    }
else
    {
    fprintf(f, "%d\t", e);
    fprintf(f, "%d\t", s+1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x2d, %eax
jne 0x27c34
movl -0x14(%rbp), %edx
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x33350
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x27c77
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
addl $0x1, %edx
leaq 0xb057d(%rip), %rsi     # 0xd81d6
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0xb0568(%rip), %rsi     # 0xd81d6
movb $0x0, %al
callq 0x6a80
jmp 0x27ca4
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0xb0551(%rip), %rsi     # 0xd81d6
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
addl $0x1, %edx
leaq 0xb0539(%rip), %rsi     # 0xd81d6
movb $0x0, %al
callq 0x6a80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainFree
void chainFree(struct chain **pChain)
/* Free up a chain. */
{
struct chain *chain = *pChain;
if (chain != NULL)
    {
    slFreeList(&chain->blockList);
    freeMem(chain->qName);
    freeMem(chain->tName);
    freez(pChain);
    }
}

// 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 0x27cfe
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2ab30
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x40d40
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/chain.c
// Function: chainFreeList
void chainFreeList(struct chain **pList)
/* Free a list of dynamically allocated chain's */
{
struct chain *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    chainFree(&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 0x27d4c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x27cb0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x27d27
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/chain.c
// Function: cBlockCmpBoth
int cBlockCmpBoth(const void *va, const void *vb)
/* Compare to sort based on query, then target. */
{
const struct cBlock *a = *((struct cBlock **)va);
const struct cBlock *b = *((struct cBlock **)vb);
int dif;
dif = a->qStart - b->qStart;
if (dif == 0)
    dif = a->tStart - b->tStart;
return dif;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x27e2a
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: cBlockCmpDiagQuery
int cBlockCmpDiagQuery(const void *va, const void *vb)
/* Compare to sort based on diagonal, then query. */
{
const struct cBlock *a = *((struct cBlock **)va);
const struct cBlock *b = *((struct cBlock **)vb);
int dif;
dif = (a->tStart - a->qStart) - (b->tStart - b->qStart);
if (dif == 0)
    dif = a->qStart - b->qStart;
return dif;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x10(%rcx), %eax
movq -0x20(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x20(%rbp), %rdx
subl 0x10(%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x27e8a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: cBlocksAddOffset
void cBlocksAddOffset(struct cBlock *blockList, int qOff, int tOff)
/* Add offsets to block list. */
{
struct cBlock *block;
for (block = blockList; block != NULL; block = block->next)
    {
    block->tStart += tOff;
    block->tEnd += tOff;
    block->qStart += qOff;
    block->qEnd += qOff;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27eee
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x27ea6
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: cBlocksFromAliSym
struct cBlock *cBlocksFromAliSym(int symCount, char *qSym, char *tSym, 
        int qPos, int tPos)
/* Convert alignment from alignment symbol (bases and dashes) format 
 * to a list of chain blocks.  The qPos and tPos correspond to the start
 * in the query and target sequences of the first letter in  qSym and tSym. */
{
struct cBlock *blockList = NULL, *block = NULL;
int i;
for (i=0; i<symCount; ++i)
    {
    if (qSym[i] == '-')
        {
        block = NULL;
        ++tPos;
        }
    else if (tSym[i] == '-')
        {
        block = NULL;
        ++qPos;
        }
    else
        {
        if (block == NULL)
            {
            AllocVar(block);
            slAddHead(&blockList, block);
            block->qStart = qPos;
            block->tStart = tPos;
            }
        block->qEnd = ++qPos;
        block->tEnd = ++tPos;
        }
    }
slReverse(&blockList);
return blockList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x27fdd
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x27f51
movq $0x0, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x27fcd
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x27f75
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27fcb
cmpq $0x0, -0x30(%rbp)
jne 0x27fab
movl $0x28, %edi
callq 0x40c50
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x27ff0
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x27fcd
jmp 0x27fcf
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x27f21
leaq -0x28(%rbp), %rdi
callq 0x2aad0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainCmpScore
int chainCmpScore(const void *va, const void *vb)
/* Compare to sort based on total score. */
{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
double diff = b->score - a->score;
if (diff < 0.0) return -1;
else if (diff > 0.0) return 1;
else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x2807c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2809a
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x28093
movl $0x1, -0x4(%rbp)
jmp 0x2809a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainCmpScoreDesc
int chainCmpScoreDesc(const void *va, const void *vb)
/* Compare to sort based on total score descending. */
{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
double diff = a->score - b->score;
if (diff < 0.0) return -1;
else if (diff > 0.0) return 1;
else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x280ec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2810a
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x28103
movl $0x1, -0x4(%rbp)
jmp 0x2810a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop