LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_toAscii
static
void uInt64_toAscii ( char* outbuf, UInt64* n )
{
   Int32  i, q;
   UChar  buf[32];
   Int32  nBuf   = 0;
   UInt64 n_copy = *n;
   do {
      q = uInt64_qrm10 ( &n_copy );
      buf[nBuf] = q + '0';
      nBuf++;
   } while (!uInt64_isZero(&n_copy));
   outbuf[nBuf] = 0;
   for (i = 0; i < nBuf; i++) 
      outbuf[i] = buf[nBuf-i-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rdi
callq 0x54d0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movslq -0x44(%rbp), %rax
movb %cl, -0x40(%rbp,%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
leaq -0x4c(%rbp), %rdi
callq 0x5540
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5402
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x547b
movl -0x44(%rbp), %eax
subl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movb -0x40(%rbp,%rax), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x544e
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_qrm10
static 
Int32 uInt64_qrm10 ( UInt64* n )
{
   UInt32 rem, tmp;
   Int32  i;
   rem = 0;
   for (i = 7; i >= 0; i--) {
      tmp = rem * 256 + n->b[i];
      n->b[i] = tmp / 10;
      rem = tmp % 10;
   }
   return rem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x7, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x5536
movl -0xc(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54e6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_isZero
static
Bool uInt64_isZero ( UInt64* n )
{
   Int32 i;
   for (i = 0; i < 8; i++)
      if (n->b[i] != 0) return 0;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x5579
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x556c
movb $0x0, -0x1(%rbp)
jmp 0x557d
jmp 0x556e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x554f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: mapSuffix
static 
Bool mapSuffix ( Char* name, 
                 const Char* oldSuffix, 
                 const Char* newSuffix )
{
   if (!hasSuffix(name,oldSuffix)) return False;
   name[strlen(name)-strlen(oldSuffix)] = 0;
   strcat ( name, newSuffix );
   return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4b70
cmpb $0x0, %al
jne 0x55bb
movb $0x0, -0x1(%rbp)
jmp 0x55fc
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2230
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: crcError
static 
void crcError ( void )
{
   fprintf ( stderr,
             "\n%s: Data integrity error when decompressing.\n",
             progName );
   showFileNames();
   cadvise();
   cleanUpAndFail( 2 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x175ad(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq 0x1907b(%rip), %rdx     # 0x1ead0
leaq 0x13f0e(%rip), %rsi     # 0x1996a
movb $0x0, %al
callq 0x2170
callq 0x47e0
callq 0x49f0
movl $0x2, %edi
callq 0x4820
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: compressedStreamEOF
static 
void compressedStreamEOF ( void )
{
  if (noisy) {
    fprintf ( stderr,
	      "\n%s: Compressed file ends unexpectedly;\n\t"
	      "perhaps it is corrupted?  *Possible* reason follows.\n",
	      progName );
    perror ( progName );
    showFileNames();
    cadvise();
  }
  cleanUpAndFail( 2 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x183f0(%rip)     # 0x1de7b
je 0x5ac2
movq 0x17564(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq 0x19032(%rip), %rdx     # 0x1ead0
leaq 0x13ef4(%rip), %rsi     # 0x19999
movb $0x0, %al
callq 0x2170
movq 0x1901d(%rip), %rdi     # 0x1ead0
callq 0x2220
callq 0x47e0
callq 0x49f0
movl $0x2, %edi
callq 0x4820
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: get_index
int get_index(int *vtx_set, int vtx_num, int target) {
    for(int i = 0; i < vtx_num; i++) {
        if(vtx_set[i] == target)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1542
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jne 0x1535
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1549
jmp 0x1537
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1515
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: add_edges
void add_edges(int vtx_num, float G[][vtx_num], int *vtx_set, char *edges) {
    char *end_str;
    char *token = strtok_r(edges, "\n", &end_str);
    int i = 0, j = 0;

    while (token != NULL) {
        char *end_token;
        //printf("debug: check line -- %s\n", token);
        int token_idx = 0;
        char *token2 = strtok_r(token, " ", &end_token);
        while (token2 != NULL) {
            if(token_idx == 0) {
                i = get_index(vtx_set, vtx_num, atoi(token2));
            } else if(token_idx == 1) {
                j = get_index(vtx_set, vtx_num, atoi(token2));
            } else {
                //printf("debug: assign edge (%d, %d): %f\n", i, j, atof(token2));
                // Assign the edge value twice as the graph is undirected
                G[i][j] = atof(token2);
                G[j][i] = atof(token2);
            }
            token2 = strtok_r(NULL, " ", &end_token);
            token_idx++;
        }
        token = strtok_r(NULL, "\n", &end_str);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1c2c(%rip), %rsi      # 0x31a8
leaq -0x28(%rbp), %rdx
callq 0x10a0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x16ce
movl $0x0, -0x44(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1a54(%rip), %rsi      # 0x3008
leaq -0x40(%rbp), %rdx
callq 0x10a0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x16b1
cmpl $0x0, -0x44(%rbp)
jne 0x15ff
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1110
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movl %eax, %edx
callq 0x1500
movl %eax, -0x34(%rbp)
jmp 0x168b
cmpl $0x1, -0x44(%rbp)
jne 0x162f
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1110
movq -0x78(%rbp), %rdi
movl -0x6c(%rbp), %esi
movl %eax, %edx
callq 0x1500
movl %eax, -0x38(%rbp)
jmp 0x1689
movq -0x50(%rbp), %rdi
callq 0x1030
movq -0x58(%rbp), %rdx
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x50(%rbp), %rdi
callq 0x1030
movq -0x58(%rbp), %rdx
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x168b
xorl %eax, %eax
movl %eax, %edi
leaq 0x1972(%rip), %rsi      # 0x3008
leaq -0x40(%rbp), %rdx
callq 0x10a0
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x15c1
xorl %eax, %eax
movl %eax, %edi
leaq 0x1aec(%rip), %rsi      # 0x31a8
leaq -0x28(%rbp), %rdx
callq 0x10a0
movq %rax, -0x30(%rbp)
jmp 0x1597
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: minDistance
int minDistance(float dist[], bool sptSet[], int V) 
{ 
    // Initialize min value 
    float min = FLT_MAX, min_index; 
  
    for (int v = 0; v < V; v++) 
        if (sptSet[v] == false && dist[v] <= min) 
            min = dist[v], min_index = v; 
  
    return min_index; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss 0x190d(%rip), %xmm0     # 0x3004
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1760
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1753
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x1753
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x18(%rbp)
cvtsi2ssl -0x20(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x1755
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1703
cvttss2si -0x1c(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: printPath
void printPath(int parent[], int j) 
{ 
      
    // Base Case : If j is source 
    if (parent[j] == -1) 
        return; 
  
    printPath(parent, parent[j]); 
  
    printf(" -- %d", j); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x178f
jmp 0x17b4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1770
movl -0xc(%rbp), %esi
leaq 0x185d(%rip), %rdi      # 0x300a
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: printSolution
int printSolution(int src, float dist[], int V, int parent[]) 
{ 
    //int src = 0; 
    printf("Vertex\t Distance\tPath"); 
    for (int i = 0; i < V; i++) 
    { 
        printf("\n%d -> %d \t\t %.2f\t\t%d", 
                      src, i, dist[i], src); 
        printPath(parent, i); 
    } 
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x1834(%rip), %rdi      # 0x3011
movb $0x0, %al
callq 0x1050
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1832
movl -0x4(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movl -0x4(%rbp), %ecx
leaq 0x1813(%rip), %rdi      # 0x3027
movb $0x1, %al
callq 0x1050
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1770
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17eb
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: rec_path
void rec_path(int j, int parent[], int vtx_set[], char *path) 
{ 
      
    // Base Case : If j is source 
    if (parent[j] == - 1) 
        return; 
  
    rec_path(parent[j], parent, vtx_set, path); 

    char tmp[20] = "";
    sprintf(tmp, " -- %d", vtx_set[j]);
    strcat(path, tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x1867
jmp 0x18bd
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1840
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x1070
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x1761(%rip), %rsi      # 0x300a
movb $0x0, %al
callq 0x1130
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1120
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/correct/correct.c
// Function: findFactor
static double
findFactor(int cycle,RRA *h)
    {
    int i,j;
    int best;
    double freq = (h->sampleRate / cycle) * Bias;
    double diff;
    double closest = 0;
    double factor;

    best = 0;
    for (i = 1; i < sizeof(freqs) / sizeof(double); ++i)
        {
        int found = 0;
        for (j = 0; !found && j < LegalNoteCount; ++j)
            if (i % 12 == LegalNoteOffsets[j])
                found = 1;
        if (!found) continue;
         
        diff = fabs(freqs[i] - freq);
        if (closest == 0 || diff < closest)
            {
            closest = diff;
            best = i;
            }
        }

    fprintf(stderr,"matching frequency to %f (%d spc) is %f, %s: ",
        freq,cycle,freqs[best],notes[best]);
    //getchar();

    factor = freqs[best] / freq;
        
    return factor;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cltd
idivl -0x4(%rbp)
cvtsi2sd %eax, %xmm0
mulsd 0xf67a(%rip), %xmm0     # 0x12920
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x6c, %rax
jae 0x339e
movl $0x0, -0x44(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0x45(%rbp)
jne 0x32f7
movl -0x18(%rbp), %eax
cmpl 0xf8c7(%rip), %eax      # 0x12bb8
setl %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x3300
jmp 0x332f
movl -0x14(%rbp), %eax
movl $0xc, %ecx
cltd
idivl %ecx
movslq -0x18(%rbp), %rcx
leaq 0x108aa(%rip), %rax     # 0x13bc0
cmpl (%rax,%rcx,4), %edx
jne 0x3322
movl $0x1, -0x44(%rbp)
jmp 0x3324
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32dd
cmpl $0x0, -0x44(%rbp)
jne 0x3337
jmp 0x3390
movslq -0x14(%rbp), %rcx
leaq 0xee4e(%rip), %rax      # 0x12190
movsd (%rax,%rcx,8), %xmm0
subsd -0x28(%rbp), %xmm0
movaps 0x9d3d(%rip), %xmm1     # 0xd090
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x336e
jp 0x336e
jmp 0x337e
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x338e
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3390
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32c1
movq 0xec53(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
movl -0x4(%rbp), %edx
movslq -0x1c(%rbp), %rcx
leaq 0xedd5(%rip), %rax      # 0x12190
movsd (%rax,%rcx,8), %xmm1
movslq -0x1c(%rbp), %rcx
leaq 0xf125(%rip), %rax      # 0x124f0
movq (%rax,%rcx,8), %rcx
leaq 0xa141(%rip), %rsi      # 0xd517
movb $0x2, %al
callq 0x21a0
movslq -0x1c(%rbp), %rcx
leaq 0xeda8(%rip), %rax      # 0x12190
movsd (%rax,%rcx,8), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/correct/correct.c
// Function: correlate
static double
correlate(int start,int offset,int length)
    {
    int i;
    double sum;

    sum = 0;
    for (i = 0; i < length; ++i)
        {
        //printf("   comparing %d with %d\n",Window[start+i],Window[offset+i]);
        //getchar();
        sum += pow(Window[start+i] - Window[offset + i],2);
        }

    return sum / length;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3484
movq 0x10f99(%rip), %rax     # 0x143d8
movl -0x4(%rbp), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x10f86(%rip), %rcx     # 0x143d8
movl -0x8(%rbp), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
subl (%rcx,%rdx,4), %eax
cvtsi2sd %eax, %xmm0
movsd 0x9c1e(%rip), %xmm1     # 0xd088
callq 0x2090
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3430
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: main
int main(int argc, char *argv[])
{
  if (argc == 1)
  {
    fsize(".");
  }
  else
  {
    while (--argc > 0)
    {
      fsize(*++argv);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x122a
leaq 0xe26(%rip), %rdi       # 0x2049
callq 0x1260
jmp 0x1256
jmp 0x122c
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x1254
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x1260
jmp 0x122c
jmp 0x1256
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: fsize
void fsize(char *name)
{
  struct stat buffer;

  if (stat(name, &buffer) == -1)
  {
    fprintf(stderr, "fsize: cannot access %s\n", name);
    return;
  }

  if ((buffer.st_mode & S_IFMT) == S_IFDIR)
  {
    dir_walk(name, fsize);
  }

  /**
   * off_t st_size         File size, in bytes
   * dev_t st_dev          ID of device containing file
   * ino_t st_ino          File serial number
   * mode_t st_mode        Mode of file (see below)
   * nlink_t st_nlink      Number of hard links
   * uid_t st_uid          User ID of the file
   * gid_t st_gid          Group ID of the file
   * dev_t st_rdev         Device ID
   * time_t st_atime       Time of last access
   * time_t st_mtime       Last data modification time
   * time_t st_ctime       Time of last status change
   * blkcnt_t st_blocks    Blocks allocated for file
   * blksize_t st_blksize  Optimal blocksize for I/O
   */

  // Printed in a similary fashion to ls -l
  print_file_flags(buffer.st_mode);
  printf("%lu ", buffer.st_nlink);
  print_file_user(buffer.st_uid);
  print_file_group(buffer.st_gid);
  print_file_size(buffer.st_size);
  print_file_time(buffer.st_atime);
  printf("%s\n", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x12a2
movq 0x2d6d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd77(%rip), %rsi       # 0x2010
movb $0x0, %al
callq 0x10b0
jmp 0x1312
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x12c1
movq -0x8(%rbp), %rdi
leaq -0x5c(%rip), %rsi       # 0x1260
callq 0x1320
movl -0x80(%rbp), %edi
callq 0x1470
movq -0x88(%rbp), %rsi
leaq 0xd52(%rip), %rdi       # 0x2029
movb $0x0, %al
callq 0x1070
movl -0x7c(%rbp), %edi
callq 0x1600
movl -0x78(%rbp), %edi
callq 0x1660
movq -0x68(%rbp), %rdi
callq 0x16c0
movq -0x50(%rbp), %rdi
callq 0x17f0
movq -0x8(%rbp), %rsi
leaq 0xd39(%rip), %rdi       # 0x2044
movb $0x0, %al
callq 0x1070
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: dir_walk
void dir_walk(char *dir_name, void (*func)(char *))
{
  char name[MAX_PATH_LEN];
  struct dirent *dir_entry;
  DIR *dir;

  if ((dir = opendir(dir_name)) == NULL)
  {
    fprintf(stderr, "dir_walk: cannot open %s\n", dir_name);
    return;
  }

  while ((dir_entry = readdir(dir)) != NULL)
  {
    if (strcmp(dir_entry->d_name, ".") == 0 || strcmp(dir_entry->d_name, "..") == 0)
    {
      continue; // Skip self and parent.
    }

    if (strlen(dir_name) + strlen(dir_entry->d_name) + 2 > MAX_PATH_LEN)
    {
      fprintf(stderr, "dir_walk: path too long\n");
    }
    else
    {
      sprintf(name, "%s/%s", dir_name, dir_entry->d_name);
      (*func)(name);
    }
  }

  closedir(dir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, -0x420(%rbp)
cmpq $0x0, %rax
jne 0x136a
movq 0x2ca8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xcd0(%rip), %rsi       # 0x202e
movb $0x0, %al
callq 0x10b0
jmp 0x1458
jmp 0x136c
movq -0x420(%rbp), %rdi
callq 0x10d0
movq %rax, -0x418(%rbp)
cmpq $0x0, %rax
je 0x144c
movq -0x418(%rbp), %rdi
addq $0x13, %rdi
leaq 0xcae(%rip), %rsi       # 0x2049
callq 0x10a0
cmpl $0x0, %eax
je 0x13c1
movq -0x418(%rbp), %rdi
addq $0x13, %rdi
leaq 0xc91(%rip), %rsi       # 0x2048
callq 0x10a0
cmpl $0x0, %eax
jne 0x13c3
jmp 0x136c
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, -0x428(%rbp)
movq -0x418(%rbp), %rdi
addq $0x13, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x428(%rbp), %rax
addq %rcx, %rax
addq $0x2, %rax
cmpq $0x400, %rax            # imm = 0x400
jbe 0x1416
movq 0x2bf5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc3e(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x10b0
jmp 0x1447
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x418(%rbp), %rcx
addq $0x13, %rcx
leaq 0xc31(%rip), %rsi       # 0x2064
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rax
leaq -0x410(%rbp), %rdi
callq *%rax
jmp 0x136c
movq -0x420(%rbp), %rdi
callq 0x1090
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_flags
void print_file_flags(mode_t st_mode)
{
  printf("%c", ((st_mode & S_IFMT) == S_IFDIR) ? 'd' : '-');
  printf("%c", (st_mode & S_IRUSR) ? 'r' : '-');
  printf("%c", (st_mode & S_IWUSR) ? 'w' : '-');
  printf("%c", (st_mode & S_IXUSR) ? 'x' : '-');
  printf("%c", (st_mode & S_IRGRP) ? 'r' : '-');
  printf("%c", (st_mode & S_IWGRP) ? 'w' : '-');
  printf("%c", (st_mode & S_IXGRP) ? 'x' : '-');
  printf("%c", (st_mode & S_IROTH) ? 'r' : '-');
  printf("%c", (st_mode & S_IWOTH) ? 'w' : '-');
  printf("%c ", (st_mode & S_IXOTH) ? 'x' : '-');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
movl $0x2d, %esi
movl $0x64, %eax
cmpl $0x4000, %ecx           # imm = 0x4000
cmovel %eax, %esi
leaq 0xbcc(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x100, %ecx            # imm = 0x100
movl $0x2d, %esi
movl $0x72, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xba5(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x80, %ecx
movl $0x2d, %esi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xb7e(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x40, %ecx
movl $0x2d, %esi
movl $0x78, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xb5a(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x20, %ecx
movl $0x2d, %esi
movl $0x72, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xb36(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x10, %ecx
movl $0x2d, %esi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xb12(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x8, %ecx
movl $0x2d, %esi
movl $0x78, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xaee(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x4, %ecx
movl $0x2d, %esi
movl $0x72, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xaca(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x2, %ecx
movl $0x2d, %esi
movl $0x77, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xaa6(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %ecx
andl $0x1, %ecx
movl $0x2d, %esi
movl $0x78, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0xa85(%rip), %rdi       # 0x206d
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_user
void print_file_user(uid_t st_uid)
{
  struct passwd *password;
  password = getpwuid(st_uid);

  if (password == NULL)
  {
    fprintf(stderr, "Error: cannot find user\n");
    return;
  }

  printf("%s ", password->pw_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x1050
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1638
movq 0x29d3(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa42(%rip), %rsi       # 0x2071
movb $0x0, %al
callq 0x10b0
jmp 0x164d
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa69(%rip), %rdi       # 0x20af
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_group
void print_file_group(gid_t st_gid)
{
  struct group *group;
  group = getgrgid(st_gid);

  if (group == NULL)
  {
    fprintf(stderr, "Error: cannot find group\n");
    return;
  }

  printf("%s ", group->gr_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x1080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1698
movq 0x2973(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x9fb(%rip), %rsi       # 0x208a
movb $0x0, %al
callq 0x10b0
jmp 0x16ad
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa09(%rip), %rdi       # 0x20af
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_size
void print_file_size(size_t size)
{
  static const char *SIZES[] = {"B", "K", "M", "G"};
  size_t div = 0;
  size_t rem = 0;

  while (size >= 1024 && div < (sizeof SIZES / sizeof *SIZES))
  {
    rem = (size % 1024);
    div++;
    size /= 1024;
  }

  printf("%6.1f%s ", (float)size + (float)rem / 1024.0, SIZES[div]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x400, -0x8(%rbp)      # imm = 0x400
movb %al, -0x19(%rbp)
jb 0x16f6
cmpq $0x4, -0x10(%rbp)
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x16ff
jmp 0x1727
movq -0x8(%rbp), %rax
andq $0x3ff, %rax            # imm = 0x3FF
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0xa, %rax
movq %rax, -0x8(%rbp)
jmp 0x16dc
movq -0x8(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x24(%rbp)
testq %rax, %rax
movss %xmm0, -0x20(%rbp)
js 0x1760
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x2c(%rbp)
testq %rax, %rax
movss %xmm0, -0x28(%rbp)
js 0x17a7
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x84b(%rip), %xmm2      # 0x2008
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rcx
leaq 0x28c0(%rip), %rax      # 0x4090
movq (%rax,%rcx,8), %rsi
leaq 0x8cf(%rip), %rdi       # 0x20aa
movb $0x1, %al
callq 0x1070
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/pim_sender.c
// Function: csum
unsigned short
csum (unsigned short *buf, int nwords)
{
	unsigned long sum;
	for (sum = 0; nwords > 0; nwords--)
		sum += *buf++;
	sum = (sum >> 16) + (sum & 0xffff);
	sum += (sum >> 16);

	return ~sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x125e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movzwl (%rax), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1233
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movq -0x18(%rbp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/pim_sender.c
// Function: make_pim_null_register
int make_pim_null_register()
{
	struct ip *iph;
	struct _SPimRegHdr *pim_reg_header;
	UINT2 *flags;
	char *header = datagram;

	if( has_local_source ) {
		iph = (struct ip*)(header);
		iph->ip_hl = 5;
		iph->ip_v = 4;
		iph->ip_tos = 0;
		iph->ip_len = htons(length);
		iph->ip_id = htonl(random());
		iph->ip_off = 0;
		iph->ip_ttl = 255;
		iph->ip_p = IPPROTO_PIM;
		iph->ip_sum = 0;
		iph->ip_src.s_addr = inet_addr (local_source);
		iph->ip_dst.s_addr = inet_addr (rp);

		header += sizeof(struct ip);
	}

	pim_reg_header = (struct _SPimRegHdr*)(header); 
	pim_reg_header->msgtpe = PIMSM_REGISTER_MSG;
	pim_reg_header->pimver = 2;
	pim_reg_header->nulbit = 1;
	flags = (UINT2*)(header + 4);
	*flags = htons(*flags);
	pim_reg_header->u2Checksum = csum((unsigned short*)pim_reg_header,sizeof(struct _SPimRegHdr)>>1);

	if( has_local_source ) {
		iph->ip_sum = csum((unsigned short*)iph, length>>1);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x2e21(%rip), %rax      # 0x40d0
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x2e0a(%rip)      # 0x40c4
je 0x1376
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %cl
andb $-0x10, %cl
orb $0x5, %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movb (%rax), %cl
andb $0xf, %cl
orb $0x40, %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movl 0x2dae(%rip), %eax      # 0x40a0
movzwl %ax, %edi
callq 0x1060
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
callq 0x10c0
movl %eax, %edi
callq 0x1080
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x6(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x67, 0x9(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xa(%rax)
leaq 0x12d89(%rip), %rdi     # 0x140d0
callq 0x10b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
leaq 0x12d84(%rip), %rdi     # 0x140e0
callq 0x10b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
andb $-0x10, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movb (%rax), %cl
andb $0xf, %cl
orb $0x20, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movw 0x4(%rax), %cx
andw $0xbfff, %cx            # imm = 0xBFFF
orw $0x4000, %cx            # imm = 0x4000
movw %cx, 0x4(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %edi
callq 0x1060
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x1220
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
cmpl $0x0, 0x2cd2(%rip)      # 0x40c4
je 0x1410
movq -0x8(%rbp), %rdi
movl 0x2ca2(%rip), %esi      # 0x40a0
sarl %esi
callq 0x1220
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/pim_sender.c
// Function: usage
void usage()
{
	printf("Usage: ./pim_sender -i local_source -r rp -t type -s mcast_source -g mcast_group -p mcast_port -c count -l length\n");
	printf(" -i local_source    local source address\n");
	printf(" -r rp              rp address\n");
	printf(" -t type            1: null register;  2: register;  3: register-stop\n");	
	printf(" -s mcast_source    multicast payload source address\n");
	printf(" -g mcast_group     multicast payload group address\n");
	printf(" -p mcast_port      multicast payload port\n");
	printf(" -c count           the packet count, default count is unlimited\n");
	printf(" -l length          pim packet length, default is 256 bytes\n");
	printf(" Version:           %s\n", version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x721(%rip), %rdi       # 0x204c
movb $0x0, %al
callq 0x1070
leaq 0x786(%rip), %rdi       # 0x20bf
movb $0x0, %al
callq 0x1070
leaq 0x7a2(%rip), %rdi       # 0x20e9
movb $0x0, %al
callq 0x1070
leaq 0x7b4(%rip), %rdi       # 0x2109
movb $0x0, %al
callq 0x1070
leaq 0x7ed(%rip), %rdi       # 0x2150
movb $0x0, %al
callq 0x1070
leaq 0x815(%rip), %rdi       # 0x2186
movb $0x0, %al
callq 0x1070
leaq 0x83c(%rip), %rdi       # 0x21bb
movb $0x0, %al
callq 0x1070
leaq 0x85a(%rip), %rdi       # 0x21e7
movb $0x0, %al
callq 0x1070
leaq 0x88e(%rip), %rdi       # 0x2229
movb $0x0, %al
callq 0x1070
leaq 0x8bd(%rip), %rdi       # 0x2266
leaq 0x8ce(%rip), %rsi       # 0x227e
movb $0x0, %al
callq 0x1070
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/joltikneq6464v13/ref/joltik.c
// Function: set_nonce_in_tweak
static void set_nonce_in_tweak(uint8_t *tweak, const uint8_t *nonce) {
    tweak[0] =	(tweak[0]&0xf0)      ^ (nonce[0] >> 4);
    tweak[1] = ((nonce[0]&0xf) << 4) ^ (nonce[1] >> 4);
    tweak[2] = ((nonce[1]&0xf) << 4) ^ (nonce[2] >> 4);
    tweak[3] = ((nonce[2]&0xf) << 4) ^ (nonce[3] >> 4);
    tweak[4] = ((nonce[3]&0xf) << 4);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
movq -0x10(%rsp), %rcx
movzbl (%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/joltikneq6464v13/ref/joltik.c
// Function: set_block_number_in_tweak
static void set_block_number_in_tweak(uint8_t *tweak, const uint64_t block_no) {
    tweak[4] = (tweak[4]&0xf0) ^ ((block_no >> 24ULL) & 0x0f);
    tweak[5] = ((block_no >> 16ULL) & 0xff);
    tweak[6] = ((block_no >>  8ULL) & 0xff);
    tweak[7] = ((block_no >>  0ULL) & 0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x4(%rax), %eax
andl $0xf0, %eax
cltq
movq -0x10(%rsp), %rcx
shrq $0x18, %rcx
andq $0xf, %rcx
xorq %rcx, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rsp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_10/calculator.c
// Function: get_line
int get_line(char line[], unsigned int max_line_len)
{
  int c, i;

  for (i = 0; i < max_line_len - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }

  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jae 0x14a6
callq 0x1060
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x14a6
cmpl $0xa, -0x10(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x14af
jmp 0x14ca
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1476
cmpl $0xa, -0x10(%rbp)
jne 0x14e9
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aegis128l/aesnic/encrypt.c
// Function: aegis128L_ad_partial
void aegis128L_ad_partial(__m128i *state, const unsigned char *ad, unsigned long long adlen)  
{
    unsigned char plaintextblock[32], ciphertextblock[32]; 
    unsigned long long i;  
     
    for (i = 0; (i+32) <= adlen; i += 32) aegis128L_enc_aut_step(ad+i, ciphertextblock, state);  

    if ( (adlen & 0x1f) != 0 )  { 
         memset(plaintextblock, 0, 32);  
         memcpy(plaintextblock, ad+i, adlen & 0x1f);  
         aegis128L_enc_aut_step(plaintextblock, ciphertextblock, state);  
    }  
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x20, %rax
cmpq 0x50(%rsp), %rax
ja 0x2e55
movq 0x58(%rsp), %rdi
addq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x1070
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
jmp 0x2e1c
movq 0x50(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
je 0x2ea6
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1030
leaq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdx
andq $0x1f, %rdx
callq 0x10e0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x1070
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aegis128l/aesnic/encrypt.c
// Function: aegis128L_enc_partial
void aegis128L_enc_partial(__m128i *state, const unsigned char *m, unsigned long long mlen, unsigned char* c)  
{
    unsigned char plaintextblock[32], ciphertextblock[32];  
    unsigned long long i;  
     
    for (i = 0; (i+32) <= mlen; i += 32) aegis128L_enc_aut_step(m+i, c+i, state);  

    if ( (mlen & 0x1f) != 0 )  {
         memset(plaintextblock, 0, 32);    
         memcpy(plaintextblock, m + i, mlen & 0x1f);    
         aegis128L_enc_aut_step(plaintextblock, ciphertextblock, state);
         memcpy(c+i,ciphertextblock,mlen & 0x1f); 
    }  
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x20, %rax
cmpq 0x60(%rsp), %rax
ja 0x2f0f
movq 0x68(%rsp), %rdi
addq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x1070
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
jmp 0x2ed1
movq 0x60(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
je 0x2f7d
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1030
leaq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x60(%rsp), %rdx
andq $0x1f, %rdx
callq 0x10e0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x1070
movq 0x58(%rsp), %rdi
addq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x60(%rsp), %rdx
andq $0x1f, %rdx
callq 0x10e0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aegis128l/aesnic/encrypt.c
// Function: aegis128L_dec_partial
void aegis128L_dec_partial(__m128i *state, unsigned char *m, unsigned long long mlen, const unsigned char *c)  
{
    unsigned char plaintextblock[32], ciphertextblock[32];  
    unsigned long long i;  
     
    for (i = 0; (i+32) <= mlen; i += 32) aegis128L_dec_aut_step(m+i, c+i, state);  

    if (  (mlen & 0x1f) != 0 )  {
        memset(ciphertextblock, 0, 32);
        memcpy(ciphertextblock, c+i, mlen & 0x1f);
        aegis128L_dec_aut_step(plaintextblock, ciphertextblock, state);
        memcpy(m+i, plaintextblock, mlen & 0x1f);

        //need to modify the state here (because in the last block, keystream is wrongly used to update the state)
        memset(plaintextblock, 0, mlen & 0x1f);
        state[0] = _mm_xor_si128( state[0], _mm_load_si128((__m128i*)plaintextblock)  ) ;
        state[4] = _mm_xor_si128( state[4], _mm_load_si128((__m128i*)(plaintextblock+16) )  ) ;
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x20, %rax
cmpq 0x58(%rsp), %rax
ja 0x2ff2
movq 0x60(%rsp), %rdi
addq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x10c0
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
jmp 0x2fb4
movq 0x58(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
je 0x3111
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1030
leaq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
andq $0x1f, %rdx
callq 0x10e0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x10c0
movq 0x60(%rsp), %rdi
addq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x58(%rsp), %rdx
andq $0x1f, %rdx
callq 0x10e0
leaq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rdx
andq $0x1f, %rdx
xorl %esi, %esi
callq 0x1030
movq 0x68(%rsp), %rax
vmovdqa (%rax), %xmm1
leaq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xb0(%rsp)
vmovdqa %xmm0, 0xa0(%rsp)
vmovdqa 0xb0(%rsp), %xmm0
vpxor 0xa0(%rsp), %xmm0, %xmm0
movq 0x68(%rsp), %rax
vmovdqa %xmm0, (%rax)
movq 0x68(%rsp), %rax
vmovdqa 0x40(%rax), %xmm1
leaq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x90(%rsp)
vmovdqa %xmm0, 0x80(%rsp)
vmovdqa 0x90(%rsp), %xmm0
vpxor 0x80(%rsp), %xmm0, %xmm0
movq 0x68(%rsp), %rax
vmovdqa %xmm0, 0x40(%rax)
addq $0xc8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fastlz.c
// Function: fastlz_decompress
int fastlz_decompress(const void* input, int length, void* output, int maxout)
{
  /* magic identifier for compression level */
  int level = ((*(const flzuint8*)input) >> 5) + 1;

  if(level == 1)
    return fastlz1_decompress(input, length, output, maxout);
  if(level == 2)
    return fastlz2_decompress(input, length, output, maxout);

  /* unknown level, trigger error */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x5, %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x3c54
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x3c90
movl %eax, -0x4(%rbp)
jmp 0x3c79
cmpl $0x2, -0x28(%rbp)
jne 0x3c72
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x4150
movl %eax, -0x4(%rbp)
jmp 0x3c79
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fastlz.c
// Function: fastlz_compress_level
int fastlz_compress_level(int level, const void* input, int length, void* output)
{
  if(level == 1)
    return fastlz1_compress(input, length, output);
  if(level == 2)
    return fastlz2_compress(input, length, output);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x46d1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x2850
movl %eax, -0x4(%rbp)
jmp 0x46f3
cmpl $0x2, -0x8(%rbp)
jne 0x46ec
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x3130
movl %eax, -0x4(%rbp)
jmp 0x46f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: tmpfile_close
static void tmpfile_close(FILE **f, char **nam)
{
if(f)
        {
        if(*f) { fclose(*f); *f = NULL; }
        }

if(nam)
        {
        if(*nam)
                {
                unlink(*nam);
                free(*nam);
                *nam = NULL;
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e2a
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4e28
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x4e2a
cmpq $0x0, -0x10(%rbp)
je 0x4e60
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4e5e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2070
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x4e60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstWriterFlushContext
void fstWriterFlushContext(void *ctx)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if(xc)
        {
        if(xc->tchn_idx > 1)
                {
                xc->flush_context_pending = 1;
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4eac
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8c(%rax)
jbe 0x4eaa
movq -0x10(%rbp), %rax
movb 0xe9(%rax), %cl
andb $-0x21, %cl
orb $0x20, %cl
movb %cl, 0xe9(%rax)
jmp 0x4eac
popq %rbp
retq
nop