LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, BOOL punch_page0 )
{
  WORD16  loc;
  WORD16  tmplc;
  int lpool_page = 0; /* Silence false uninitialized error from GCC */
  int i;

  for (i = MAX_PAGES-1; i >= 0;  i--) {
    lpool_page = (i << 7) & 07600;

    if ( p[i].loc != p[i].last_punched && (punch_page0 || lpool_page != 0) )
    {
      if( !rim_mode )
      {
        /* Put out origin if not in rim mode.                                 */
        punchOrigin( p[i].loc | lpool_page );
      }
      /* Put the literals in the object file.                                 */
      for( loc = p[i].loc; loc < p[i].last_punched; loc++ )
      {
        tmplc = loc + lpool_page;
        printLine( line, (field | tmplc), p[i].pool[loc], LOC_VAL );
        punchLocObject( tmplc, p[i].pool[loc] );
      }
      p[i].last_punched = p[i].loc;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x1f80(%rdi), %r12
movl $0x1f, %r13d
movl $0xf80, %ebx            # imm = 0xF80
leaq 0x97da(%rip), %r8       # 0xd790
movl %esi, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
testb %sil, %sil
setne %al
movq %r13, %rdi
shlq $0x7, %rdi
movq %r13, %rcx
shlq $0x8, %rcx
leaq (%rcx,%r13,4), %r14
movzwl (%r15,%r14), %ebp
testl $0xf80, %edi            # imm = 0xF80
setne %cl
cmpw 0x2(%r15,%r14), %bp
je 0x4095
orb %cl, %al
je 0x4095
cmpb $0x0, 0x734d(%rip)      # 0xb34d
jne 0x4023
orl %ebp, %edi
shrl $0x6, %edi
andl $0x3f, %edi
orl $0x40, %edi
callq 0x6a41
andl $0x3f, %ebp
movl %ebp, %edi
callq 0x6a41
leaq 0x976d(%rip), %r8       # 0xd790
addq %r15, %r14
movswq (%r14), %rbp
cmpw 0x2(%r14), %bp
jge 0x4083
movl %ebx, %r15d
andl $0xff80, %r15d          # imm = 0xFF80
addl %ebp, %r15d
movzwl 0x971d(%rip), %eax      # 0xd762
orw %r15w, %ax
movswl (%r12,%rbp,2), %edx
movswl %ax, %esi
movq %r8, %rdi
movl $0x3, %ecx
callq 0x40b8
movswl (%r12,%rbp,2), %esi
movswl %r15w, %edi
callq 0x69fc
leaq 0x971d(%rip), %r8       # 0xd790
incq %rbp
movswq 0x2(%r14), %rax
incl %r15d
cmpq %rax, %rbp
jl 0x403e
movzwl (%r14), %eax
movw %ax, 0x2(%r14)
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %r15
addq $-0x104, %r12           # imm = 0xFEFC
addl $-0x80, %ebx
subq $0x1, %r13
jae 0x3fbf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printLine
void printLine( char *line, WORD16 loc, WORD16 val, LINESTYLE_T linestyle )
{
  char rlc;

  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;

  if (reloc == 0)
  {
    rlc = ' ';
  }
  else
  {
    rlc = '*';
  }

  switch( linestyle )
  {
  default:
  case LINE:
    fprintf(listfile, "%5d              ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    fprintf(listfile, "%5d        %4.4o  ", lineno, val );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      if( indirect_generated )
      {
        fprintf( listfile, "%5d %5.5o%c %4.4o@ ", lineno, loc, rlc, val );
      }
      else
      {
        fprintf( listfile, "%5d %5.5o%c %4.4o  ", lineno, loc, rlc, val );
      }
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.5o%c %4.4o\n", loc, rlc, val );
    }
    break;

  case LOC_VAL:
    fprintf( listfile, "      %5.5o%c %4.4o\n", loc, rlc, val );
    break;
  }
  printErrorMessages();
}

// Assembly:
cmpq $0x0, 0x7480(%rip)      # 0xb540
je 0x412c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x67bc
incl 0x9695(%rip)            # 0xd774
incl 0x732f(%rip)            # 0xb414
cmpw $0x0, 0x9679(%rip)      # 0xd766
movl $0x20, %ecx
movl $0x2a, %eax
cmovel %ecx, %eax
cmpl $0x1, %r15d
je 0x4161
cmpl $0x2, %r15d
je 0x4137
cmpl $0x3, %r15d
je 0x4140
movq 0x742d(%rip), %rdi      # 0xb540
movl 0x9653(%rip), %edx      # 0xd76c
leaq 0x37cd(%rip), %rsi      # 0x78ed
xorl %eax, %eax
callq 0x2120
jmp 0x41b9
movl $0x0, 0x72b6(%rip)      # 0xb3ec
retq
cmpb $0x0, 0x962a(%rip)      # 0xd768
je 0x4181
movq 0x73f9(%rip), %rdi      # 0xb540
movswl %r14w, %edx
movswl %bp, %r8d
leaq 0x37e4(%rip), %rsi      # 0x793a
movl %eax, %ecx
xorl %eax, %eax
callq 0x2120
jmp 0x41cf
movq 0x73d8(%rip), %rdi      # 0xb540
movl 0x95fe(%rip), %edx      # 0xd76c
movswl %bp, %ecx
leaq 0x3787(%rip), %rsi      # 0x78ff
xorl %eax, %eax
callq 0x2120
jmp 0x41b9
cmpb $0x0, 0x96a0(%rip)      # 0xd828
movq 0x73b1(%rip), %rdi      # 0xb540
movl 0x95d7(%rip), %edx      # 0xd76c
movswl %r14w, %ecx
movswl %bp, %r9d
leaq 0x3782(%rip), %r8       # 0x7926
leaq 0x3767(%rip), %rsi      # 0x7912
cmoveq %r8, %rsi
movl %eax, %r8d
xorl %eax, %eax
callq 0x2120
movq 0x7380(%rip), %rsi      # 0xb540
movq %rbx, %rdi
callq 0x20c0
movb $0x1, 0x9599(%rip)      # 0xd768
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6901
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: lexemeToName
char *lexemeToName( char *name, int from, int term )
{
  int  to;

  to = 0;

  while( from < term && to < ( SYMLEN - 1 ))
  {
    name[to++] = toupper( line[from++] );
  }

  while( to < SYMLEN )
  {
    name[to++] = '\0';
  }
  return( name );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl %edx, %esi
jge 0x4362
movl %edx, %ebp
movl %esi, %r14d
callq 0x2030
movslq %r14d, %rdx
movslq %ebp, %rsi
leaq 0x1(%rdx), %rdi
xorl %r8d, %r8d
leaq 0x9458(%rip), %r9       # 0xd790
movq (%rax), %rcx
leaq (%rdi,%r8), %r10
leaq (%rdx,%r8), %r11
movsbq (%r9,%r11), %r11
movb (%rcx,%r11,4), %r11b
leaq 0x1(%r8), %rcx
movb %r11b, (%rbx,%r8)
cmpq %rsi, %r10
jge 0x4362
cmpq $0x5, %r8
movq %rcx, %r8
jb 0x4338
cmpl $0x6, %ecx
ja 0x437a
movl %ecx, %edi
addq %rbx, %rdi
movl $0x7, %edx
subl %ecx, %edx
xorl %esi, %esi
callq 0x20d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: errorSymbol
void errorSymbol( EMSG_T *mesg, char *name, int col )
{
  char   linecol[12];
  char  *s;

  if( pass == 2 )
  {
    s = ( name == NULL ) ? "" : name ;
    errors++;
    sprintf( linecol, "(%d:%d)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s \"%s\" at Loc = %5.5o\n",
                                      filename, linecol, mesg->file, s, clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
cmpl $0x2, 0x7067(%rip)      # 0xb3f0
jne 0x4417
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x333d(%rip), %r15      # 0x76e6
cmovneq %rsi, %r15
incl 0x7035(%rip)            # 0xb3e8
movl 0x93b3(%rip), %edx      # 0xd76c
leal 0x1(%rbx), %ecx
leaq 0x3670(%rip), %rsi      # 0x7a33
leaq 0xc(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2180
movq 0x7007(%rip), %rdi      # 0xb3e0
movq 0x8(%r14), %r8
movswl 0x937c(%rip), %eax      # 0xd760
movl %eax, (%rsp)
leaq 0x364d(%rip), %rsi      # 0x7a3b
leaq 0x71eb(%rip), %rdx      # 0xb5e0
movq %r12, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6b88
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, 0x93fa(%rip)      # 0xd818
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: nextLexBlank
void nextLexBlank()
{
  nextLexeme();
  if( is_blank( delimiter ))
  {
    errorMessage( &illegal_blank, lexstart - 1 );
  }
  delimiter = line[lexterm];
}

// Assembly:
pushq %rax
callq 0x3b84
movzbl 0x937b(%rip), %eax      # 0xd820
cmpq $0x3e, %rax
ja 0x44cf
movabsq $0x4000000100001200, %rcx # imm = 0x4000000100001200
btq %rax, %rcx
jae 0x44cf
movl 0x9353(%rip), %esi      # 0xd814
decl %esi
leaq 0x6c5e(%rip), %rdi      # 0xb128
callq 0x5ab5
movslq 0x9346(%rip), %rax      # 0xd81c
leaq 0x92b3(%rip), %rcx      # 0xd790
movb (%rax,%rcx), %al
movb %al, 0x933a(%rip)       # 0xd820
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: evalSymbol
SYM_T *evalSymbol()
{
  char   name[SYMLEN];
  SYM_T *sym;

  sym = lookup( lexemeToName( name, lexstart, lexterm ));

  /* The symbol goes in the concordance iff it is in a different position in  */
  /* the assembler source file.                                               */
  if( lexstart != last_xref_lexstart ||  lineno != last_xref_lineno )
  {
    sym->xref_count++;          /* Count the number of references to symbol.  */
    last_xref_lexstart = lexstart;
    last_xref_lineno = lineno;

    /* Put the line number in the concordance table.                          */
    if( xref && pass == 2 )
    {
      xreftab[sym->xref_index + sym->xref_count] = lineno;
    }
  }

  return( sym );
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x9227(%rip), %esi      # 0xd814
movl 0x9229(%rip), %edx      # 0xd81c
leaq 0x9(%rsp), %rbx
movq %rbx, %rdi
callq 0x430d
movq %rbx, %rdi
callq 0x41de
movl 0x9206(%rip), %edx      # 0xd814
cmpl 0x9164(%rip), %edx      # 0xd778
jne 0x4624
movl 0x9150(%rip), %ecx      # 0xd76c
cmpl 0x915a(%rip), %ecx      # 0xd77c
je 0x4664
movslq 0x14(%rax), %rcx
incq %rcx
movl %ecx, 0x14(%rax)
movl %edx, 0x9144(%rip)      # 0xd778
movl 0x9132(%rip), %edx      # 0xd76c
movl %edx, 0x913c(%rip)      # 0xd77c
cmpb $0x0, 0x6d0a(%rip)      # 0xb351
je 0x4664
cmpl $0x2, 0x6da0(%rip)      # 0xb3f0
jne 0x4664
movq 0x6ef7(%rip), %rsi      # 0xb550
movslq 0x10(%rax), %rdi
addq %rcx, %rdi
movw %dx, (%rsi,%rdi,2)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: incrementClc
WORD16 incrementClc()
{
  testForLiteralCollision( clc );

  /* Incrementing the location counter is not to change field setting.        */
  clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
  fieldlc = clc & 07777;
  return( clc );
}

// Assembly:
pushq %rax
movswl 0x812f(%rip), %edi      # 0xd760
callq 0x6738
movzwl 0x8123(%rip), %eax      # 0xd760
movl %eax, %ecx
andl $0x7000, %ecx           # imm = 0x7000
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x8111(%rip)       # 0xd764
orl %ecx, %eax
movw %ax, 0x8104(%rip)       # 0xd760
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: fixMRIInstruction
WORD16 fixMRIInstruction(WORD16 instruction, WORD16 value)
{
        /* Now have the address part of the MRI instruction.                  */
        if( value < 00200 )
        {
          instruction |= value;        /* Page zero MRI.                             */
        }
        else if( (( fieldlc + reloc ) & 07600 ) <= value
             && value <= ((( fieldlc + reloc ) & 07600) | 0177 ))
        {
          instruction |= ( PAGE_BIT | (value & ADDRESS_FIELD )); /* Current page MRI */
        }
        else
        {
          if(( instruction & INDIRECT_BIT ) == INDIRECT_BIT )
          {
            /* Already indirect, can't generate                               */
            errorSymbol( &illegal_indirect, NULL, lexstartprev );
          }
          else
          {
            if( literals_ok )
            {
              /* Now fix off page reference.                                  */
              /* Search current page literal pool for needed instruction.           */
              /* Set Indirect Current Page                                    */
              instruction |= ( 00600 | insertLiteral( cp, value, GET_PAGE_INDEX(clc) ));
              indirect_generated = TRUE;
              if (pass == 2)
              {
                links++;
              }
            }
            else
            {
              errorSymbol( &illegal_reference, NULL, lexstartprev );
              instruction |= ( value & 0177 );
            }
          }
        }
   return instruction;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
cmpw $0x7f, %bp
jg 0x5674
orl %ebx, %ebp
movl %ebp, %ebx
jmp 0x5726
movzwl %bp, %eax
movzwl 0x80e6(%rip), %ecx      # 0xd764
movzwl 0x80e1(%rip), %edx      # 0xd766
addl %ecx, %edx
andl $0xf80, %edx            # imm = 0xF80
cmpl %eax, %edx
seta %cl
orl $0x7f, %edx
cmpl %eax, %edx
setb %al
orb %cl, %al
je 0x56e9
btl $0x8, %ebx
jb 0x56f7
cmpb $0x0, 0x5c9f(%rip)      # 0xb34a
je 0x570d
movzwl 0x80ac(%rip), %edx      # 0xd760
shrl $0x7, %edx
andl $0x1f, %edx
movswl %bp, %esi
leaq 0x5f9c(%rip), %rdi      # 0xb660
callq 0x572f
orl %eax, %ebx
orl $0x180, %ebx            # imm = 0x180
movb $0x1, 0x8150(%rip)      # 0xd828
cmpl $0x2, 0x5d11(%rip)      # 0xb3f0
jne 0x5726
incl 0x5e71(%rip)            # 0xb558
jmp 0x5726
movzbl %bpl, %eax
orl %eax, %ebx
orl $0x80, %ebx
jmp 0x5726
movl 0x8127(%rip), %edx      # 0xd824
leaq 0x5aa4(%rip), %rdi      # 0xb1a8
xorl %esi, %esi
callq 0x4382
jmp 0x5726
movl 0x8111(%rip), %edx      # 0xd824
leaq 0x5a9e(%rip), %rdi      # 0xb1b8
xorl %esi, %esi
callq 0x4382
andl $0x7f, %ebp
orl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: insertLiteral
WORD16 insertLiteral( LPOOL_T *pool, WORD16 value, int fieldpage_index )
{
  WORD16  ix;
  LPOOL_T *p;

  p = &pool[fieldpage_index];

  /* Search the literal pool for any occurence of the needed value.           */
  ix = PAGE_SIZE - 1;
  while( ix >= p->loc && p->pool[ix] != value )
  {
    ix--;
  }

  /* Check if value found in literal pool. If not, then insert value.         */
  if( ix < p->loc )
  {
    (p->loc)--;
    p->pool[p->loc] = value;
    ix = p->loc;
    if( max_page_used[fieldpage_index] >= p->loc ) {
      if ( (fieldpage_index & 017) == 0 )
      {
        errorMessage( &pz_literal_overflow, -1 );
      }
      else
      {
        errorMessage( &literal_overflow, -1 );
      }
    }
  }
  return( ix );
}

// Assembly:
pushq %rbx
movslq %edx, %rax
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %r8
leaq (%rdi,%r8), %rcx
movzwl (%rdi,%r8), %edi
cmpw $0x7f, %di
setg %r8b
jg 0x577e
movw $0x7f, %bx
cmpw %si, 0x102(%rcx)
je 0x5779
movw $0x7f, %bx
decl %ebx
cmpw %di, %bx
setl %r8b
jl 0x577e
movswq %bx, %r9
cmpw %si, 0x4(%rcx,%r9,2)
jne 0x5762
testb %r8b, %r8b
je 0x57ba
decl %edi
movw %di, (%rcx)
movswq %di, %rdi
movw %si, 0x4(%rcx,%rdi,2)
movswl (%rcx), %ebx
leaq 0x7f4a(%rip), %rcx      # 0xd6e0
cmpl %ebx, (%rcx,%rax,4)
jl 0x57ba
testb $0xf, %dl
leaq 0x5a63(%rip), %rax      # 0xb208
leaq 0x5a4c(%rip), %rdi      # 0xb1f8
cmoveq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5ab5
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, int col )
{
  char   linecol[12];

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, "(%d:%d)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc = %5.5o\n",
                                         filename, linecol, mesg->file, clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
cmpl $0x2, 0x5934(%rip)      # 0xb3f0
jne 0x5b2f
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
incl 0x5916(%rip)            # 0xb3e8
movl 0x7c94(%rip), %edx      # 0xd76c
leal 0x1(%rbx), %ecx
leaq 0x1f51(%rip), %rsi      # 0x7a33
leaq 0x4(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2180
movq 0x58e8(%rip), %rdi      # 0xb3e0
movq 0x8(%r14), %r8
movswl 0x7c5c(%rip), %r9d      # 0xd760
leaq 0x1f59(%rip), %rsi      # 0x7a64
leaq 0x5ace(%rip), %rdx      # 0xb5e0
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6b88
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x7ce2(%rip)      # 0xd818
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: moveToEndOfLine
void moveToEndOfLine()
{
  while( !isend( line[cc] )) cc++;
  lexstart = cc;
  lexterm = cc;
  lexstartprev = lexstart;
}

// Assembly:
movslq 0x7cee(%rip), %rax      # 0xd82c
leaq 0x7c4b(%rip), %rcx      # 0xd790
addq %rax, %rcx
movzbl (%rcx), %edx
testl %edx, %edx
je 0x5b61
cmpl $0xa, %edx
je 0x5b61
incl %eax
movl %eax, 0x7cd0(%rip)      # 0xd82c
incq %rcx
jmp 0x5b48
movl %eax, 0x7cad(%rip)      # 0xd814
movl %eax, 0x7caf(%rip)      # 0xd81c
movl %eax, 0x7cb1(%rip)      # 0xd824
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: evalDubl
WORD32 evalDubl( WORD32 initial_value )
{
  WORD32  digit;
  int     from;
  WORD32  dublvalue;
  WORD32  olddublvalue;

  overflow = FALSE;
  delimiter = line[lexterm];
  from = lexstart;
  dublvalue = initial_value;

  while( from < lexterm )
  {
    if( isdigit( line[from] ))
    {
      olddublvalue = dublvalue;
      digit = (WORD32)( line[from++] - '0' );
      dublvalue = dublvalue * 10 + digit;
      if( dublvalue < olddublvalue )
      {
        overflow = TRUE;
      }
    }
    else
    {
      errorLexeme( &not_a_number, from );
      dublvalue = 0;
      from = lexterm;
    }
  }
  return( dublvalue );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbp
movb $0x0, 0x78e6(%rip)      # 0xd834
movslq 0x78c7(%rip), %r13      # 0xd81c
leaq 0x7834(%rip), %r12      # 0xd790
movb (%r13,%r12), %al
movb %al, 0x78b9(%rip)       # 0xd820
movl 0x78a7(%rip), %ebx      # 0xd814
cmpl %r13d, %ebx
jge 0x5fef
callq 0x21c0
movq %rax, %r14
leaq 0x1(%rsp), %r15
movq (%r14), %rcx
movslq %ebx, %rax
movsbq (%rax,%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x5fbd
movl 0x787d(%rip), %esi      # 0xd814
movq %r15, %rdi
movl %r13d, %edx
callq 0x430d
leaq 0x51bf(%rip), %rdi      # 0xb168
movq %r15, %rsi
movl %ebx, %edx
callq 0x4382
movl 0x7863(%rip), %ebx      # 0xd81c
xorl %eax, %eax
jmp 0x5fde
incl %ebx
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
leaq (%rax,%rcx,2), %rax
addq $-0x30, %rax
cmpq %rbp, %rax
jge 0x5fde
movb $0x1, 0x7856(%rip)      # 0xd834
movl 0x7837(%rip), %r13d     # 0xd81c
movq %rax, %rbp
cmpl %r13d, %ebx
jl 0x5f7f
jmp 0x5ff2
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: normalizeFltg
void normalizeFltg( FLTG_T *fltg )
{
  /* Normalize the floating point number.                                     */
  if( fltg->mantissa != 0 )
  {
    if(( fltg->mantissa & ~0x3FFFFFFL ) == 0 )
    {
      while(( fltg->mantissa & ~0x1FFFFFFL ) == 0 )

      {
        fltg->mantissa <<= 1;
        fltg->exponent--;
      }
    }
    else
    {
      while(( fltg->mantissa & ~0x3FFFFFFL ) != 0 )
      {
        fltg->mantissa >>= 1;
        fltg->exponent++;
      }
    }
  }
  else
  {
    fltg->exponent = 0;
  }
  return;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x6714
movq 0x8(%rdi), %rax
cmpq $0x4000000, %rcx        # imm = 0x4000000
jae 0x6718
cmpq $0x1ffffff, %rax        # imm = 0x1FFFFFF
ja 0x6737
movzwl (%rdi), %ecx
movq %rax, %rdx
leaq (%rdx,%rdx), %rax
decl %ecx
cmpq $0x1000000, %rdx        # imm = 0x1000000
movq %rax, %rdx
jb 0x6700
jmp 0x6730
xorl %ecx, %ecx
jmp 0x6734
cmpq $0x4000000, %rax        # imm = 0x4000000
jb 0x6737
movzwl (%rdi), %ecx
sarq %rax
incl %ecx
cmpq $0x3ffffff, %rax        # imm = 0x3FFFFFF
ja 0x6723
movq %rax, 0x8(%rdi)
movw %cx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printPageBreak
void printPageBreak()
{
  if( page_lineno >= LIST_LINES_PER_PAGE )
         /*  ( list_lineno % LIST_LINES_PER_PAGE ) == 0 ) */
  {
    if( !list_title_set )
    {
      /* strcpy( list_title, line ); */
      if( list_title[strlen(list_title) - 1] == '\n' )
      {
        list_title[strlen(list_title) - 1] = '\0';
      }
      if( strlen( list_title ) > TITLELEN )
      {
        list_title[TITLELEN] = '\0';
      }
      list_title_set = TRUE;
    }
    topOfForm( list_title, NULL );

  }
}

// Assembly:
cmpl $0x37, 0x4c51(%rip)     # 0xb414
jl 0x6819
cmpb $0x0, 0x6fb4(%rip)      # 0xd780
jne 0x680b
pushq %rbx
leaq 0x707a(%rip), %rbx      # 0xd850
movq %rbx, %rdi
callq 0x20a0
cmpb $0xa, -0x1(%rax,%rbx)
jne 0x67ea
movb $0x0, -0x1(%rax,%rbx)
leaq 0x705f(%rip), %rdi      # 0xd850
callq 0x20a0
cmpq $0x40, %rax
popq %rbx
jb 0x6804
movb $0x0, 0x708b(%rip)      # 0xd88f
movb $0x1, 0x6f75(%rip)      # 0xd780
leaq 0x703e(%rip), %rdi      # 0xd850
xorl %esi, %esi
jmp 0x681a
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: topOfForm
void topOfForm( char *title, char *sub_title )
{
  char temp[10];

  list_pageno++;
  strcpy( temp, s_page );
  sprintf( temp, "%s %d", s_page, list_pageno );

  /* Output a top of form if not the first page of the listing.               */
  if( list_pageno > 1 )
  {
    fprintf( listfile, "\f" );
  }
  fprintf( listfile, "\n\n\n      %-63s %10s\n", title, temp );

  /* Reset the current page line counter.                                     */
  page_lineno = 3;
  if( sub_title != NULL )
  {
    fprintf( listfile, "%80s\n", sub_title );
    page_lineno++;
  }
  else
  {
    fprintf( listfile, "\n" );
    page_lineno++;
  }
  fprintf( listfile, "\n" );
  page_lineno++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x6f3e(%rip), %ebp      # 0xd770
incl %ebp
movl %ebp, 0x6f36(%rip)      # 0xd770
leaq 0x4890(%rip), %r15      # 0xb0d1
leaq 0x6(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2070
leaq 0x11b5(%rip), %rsi      # 0x7a0d
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2180
cmpl $0x2, 0x6f02(%rip)      # 0xd770
jl 0x6881
movq 0x4cc9(%rip), %rsi      # 0xb540
movl $0xc, %edi
callq 0x20e0
movq 0x4cb8(%rip), %rdi      # 0xb540
leaq 0x1184(%rip), %rsi      # 0x7a13
leaq 0x6(%rsp), %rcx
movq %r14, %rdx
xorl %eax, %eax
callq 0x2120
movl $0x3, 0x4b6c(%rip)      # 0xb414
movq 0x4c91(%rip), %rax      # 0xb540
testq %rbx, %rbx
je 0x68ca
leaq 0x116d(%rip), %rsi      # 0x7a28
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
jmp 0x68d7
movl $0xa, %edi
movq %rax, %rsi
callq 0x20e0
incl 0x4b37(%rip)            # 0xb414
movq 0x4c5c(%rip), %rsi      # 0xb540
movl $0xa, %edi
callq 0x20e0
incl 0x4b20(%rip)            # 0xb414
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printErrorMessages
void printErrorMessages()
{
  WORD16  ix;
  WORD16  iy;

  if( listfile != NULL )
  {
    /* If any errors, display them now.                                       */
    for( iy = 0; iy < save_error_count; iy++ )
    {
      printPageBreak();
      fprintf( listfile, "%-18.18s", error_list[iy].mesg );
      if( error_list[iy].col >= 0 )
      {
        for( ix = 0; ix < error_list[iy].col; ix++ )
        {
          if( line[ix] == '\t' )
          {
            putc( '\t', listfile );
          }
          else
          {
            putc( ' ', listfile );
          }
        }
        fputs( "^", listfile );
        list_lineno++;
        page_lineno++;
      }
      fputs( "\n", listfile );
    }
  }
  save_error_count = 0;
}

// Assembly:
cmpq $0x0, 0x4c37(%rip)      # 0xb540
je 0x69f1
cmpl $0x0, 0x4ad6(%rip)      # 0xb3ec
jle 0x69f1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6fb2(%rip), %r12      # 0xd8e0
leaq 0x6e5b(%rip), %r13      # 0xd790
leaq 0xda9(%rip), %r15       # 0x76e5
xorl %ebp, %ebp
callq 0x67bc
movq 0x4bf6(%rip), %rdi      # 0xb540
movswq %bp, %r14
shlq $0x4, %r14
movq (%r14,%r12), %rdx
leaq 0xff2(%rip), %rsi       # 0x794f
xorl %eax, %eax
callq 0x2120
cmpl $0x0, 0x8(%r14,%r12)
js 0x69c3
addq %r12, %r14
cmpl $0x0, 0x8(%r14)
jle 0x69a4
xorl %ebx, %ebx
movswq %bx, %rax
cmpb $0x9, (%rax,%r13)
movl $0x9, %edi
je 0x698d
movl $0x20, %edi
movq 0x4bac(%rip), %rsi      # 0xb540
callq 0x2100
incl %ebx
movswl %bx, %eax
cmpl %eax, 0x8(%r14)
jg 0x6978
movq 0x4b95(%rip), %rsi      # 0xb540
leaq 0xfa6(%rip), %rdi       # 0x7958
callq 0x20c0
incl 0x6db7(%rip)            # 0xd774
incl 0x4a51(%rip)            # 0xb414
movq 0x4b76(%rip), %rsi      # 0xb540
movq %r15, %rdi
callq 0x20c0
incl %ebp
movswl %bp, %eax
cmpl %eax, 0x4a0f(%rip)      # 0xb3ec
jg 0x693e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x0, 0x49f1(%rip)      # 0xb3ec
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchLocObject
void punchLocObject( WORD16 loc, WORD16 val )
{
  if( rim_mode )
  {
    punchOrigin( loc );
  }
  punchObject(( val >> 6 ) & 0077 );
  punchObject( val & 0077 );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpb $0x0, 0x4945(%rip)      # 0xb34d
je 0x6a24
movl %edi, %ebp
shrl $0x6, %edi
andl $0x3f, %edi
orl $0x40, %edi
callq 0x6a41
andl $0x3f, %ebp
movl %ebp, %edi
callq 0x6a41
movl %ebx, %edi
shrl $0x6, %edi
andl $0x3f, %edi
callq 0x6a41
andl $0x3f, %ebx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6a41
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchObject
void punchObject( WORD16 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
movq 0x4a68(%rip), %rsi      # 0xb4b0
testq %rsi, %rsi
je 0x6a61
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20e0
addw %bx, 0x49b0(%rip)       # 0xb410
popq %rbx
movb $0x1, 0x48e0(%rip)      # 0xb348
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: binarySearch
int binarySearch( char *name, int start, int symbol_count )
{
  int     lx;                   /* Left index                                 */
  int     mx;                   /* Middle index                               */
  int     rx;                   /* Right index                                */
  int     compare;              /* Results of comparison                      */

  lx = start;
  rx = symbol_count - 1;
  while( lx <= rx )
  {
    mx = ( lx + rx ) / 2;   /* Find center of search area.                    */

    compare = strcmp( name, symtab[mx].name );

    if( compare < 0 )
    {
      rx = mx - 1;
    }
    else if( compare > 0 )
    {
      lx = mx + 1;
    }
    else
    {
      return( mx );         /* Found a match in symbol table.                 */
    }
  } /* end while                                                              */
  return( ~lx );            /* Return insertion point.                        */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
cmpl %esi, %edx
jle 0x6ac1
movl %edx, %r15d
movq %rdi, %r14
decl %r15d
movq 0x4971(%rip), %r12      # 0xb3f8
leal (%r15,%rbx), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,8), %rsi
addq $0x4, %rsi
movq %r14, %rdi
callq 0x2110
testl %eax, %eax
jns 0x6ab6
decl %ebp
movl %ebp, %r15d
jmp 0x6abc
je 0x6ac5
incl %ebp
movl %ebp, %ebx
cmpl %r15d, %ebx
jle 0x6a87
notl %ebx
movl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: saveError
void saveError( char *mesg, int col )
{
  if( save_error_count < DIM( error_list ))
  {
    error_list[save_error_count].mesg = mesg;
    error_list[save_error_count].col = col;
    save_error_count++;
  }
  error_in_line = TRUE;

  if( listed )
  {
    printErrorMessages();
  }
}

// Assembly:
movl 0x485e(%rip), %eax      # 0xb3ec
cmpq $0x13, %rax
ja 0x6bb2
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x6d3e(%rip), %rdx      # 0xd8e0
movq %rdi, (%rcx,%rdx)
movl %esi, 0x8(%rcx,%rdx)
incl %eax
movl %eax, 0x483a(%rip)      # 0xb3ec
movb $0x1, 0x6c5f(%rip)      # 0xd818
cmpb $0x0, 0x6ba8(%rip)      # 0xd768
jne 0x6901
retq
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/9-File/full_buf.c
// Function: main
int main(void)
{
	if(setvbuf(stdout, NULL, _IOFBF, 0) != 0)
	{
		perror("setvbuf");
		exit(1);
	}

	printf("H");	sleep(1);
	printf("E");	sleep(1);
	printf("L");	sleep(1);
	printf("L");	sleep(1);
	printf("O");	sleep(1);
	printf("\n");	sleep(1);

	return 0;
}

// Assembly:
pushq %rax
movq 0x2e3c(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1040
testl %eax, %eax
jne 0x1232
movl $0x48, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x45, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x4c, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x4c, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x4f, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0xa, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp-test.c
// Function: on_signal
static int on_signal(void *poller, struct poller_item *item)
{
	ssize_t rd;
	struct signalfd_siginfo fdsi;

	while (1) {
		rd = read(item->fd, &fdsi, sizeof(fdsi));
		if (rd < 0 && errno == EAGAIN) {
			return 0;
		}
		else if (rd != sizeof(fdsi)) {
			/* Consider as fatal error */
			assert(0);
			return -1;
		}

		switch (fdsi.ssi_signo) {
		case SIGINT:
		case SIGTERM:
			/* Stop further processing, termination requested */
			return 1;
		default:
			assert(0);
			return -1;
		}
	}

	/* Unreachable line */
	assert(0);
	return -1;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movl (%rsi), %edi
movq %rsp, %rsi
movl $0x80, %edx
callq 0x1130
movq %rax, %rbx
testq %rax, %rax
jns 0x177e
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
je 0x1799
cmpq $0x80, %rbx
jne 0x17a2
movl $0x1, %eax
movl (%rsp), %ecx
cmpl $0x2, %ecx
je 0x1799
cmpl $0xf, %ecx
jne 0x17c1
addq $0x80, %rsp
popq %rbx
retq
leaq 0x3ea2(%rip), %rdi      # 0x564b
leaq 0x38d5(%rip), %rsi      # 0x5085
leaq 0x3976(%rip), %rcx      # 0x512d
movl $0xbb, %edx
callq 0x10d0
leaq 0x3e83(%rip), %rdi      # 0x564b
leaq 0x38b6(%rip), %rsi      # 0x5085
leaq 0x3957(%rip), %rcx      # 0x512d
movl $0xc5, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp-test.c
// Function: on_sock_connection
static int on_sock_connection(void *poller, struct poller_item *item)
{
	int err, psock;
	struct sockaddr addr;
	socklen_t len = sizeof(addr);
	struct loop_ctx *ctx = item->data;
	struct io_req *req;
	struct peer *peer;

	psock = accept4(item->fd, &addr, &len, SOCK_CLOEXEC);
	if (psock < 0) {
		switch (errno) {
		case EWOULDBLOCK:
			break;
		default:
			err = -errno;
			assert(0);
			return err;
		}

		return 0;
	}

	peer = malloc(sizeof(*peer));
	assert(peer);
	peer->psock = psock;
	peer->ctx = ctx;
	INIT_LIST_HEAD(&peer->list);
	io_queue_init(&peer->q);
	err = io_queue_bind(&peer->q, ctx->poller, psock);
	assert(err == 0);
	err = zmtp_init(&peer->zmtp, &peer->q, ZMTP_REP);
	assert(err == 0);

	req = io_req_create(&peer->q, REQ_RD, peer, on_read);
	assert(req);
	req->buf = (struct io_buf){
		.iov_num  = 1,
		.is_vari_len = true,
	};
	err = io_queue_submit(req);
	assert(err == 0);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4(%rsp), %rdx
movl $0x10, (%rdx)
movq 0x10(%rsi), %r15
movl (%rsi), %edi
leaq 0x8(%rsp), %rsi
movl $0x80000, %ecx          # imm = 0x80000
callq 0x10b0
testl %eax, %eax
js 0x18fa
movl %eax, %ebp
movl $0x1c8, %edi            # imm = 0x1C8
callq 0x1180
testq %rax, %rax
je 0x1915
movq %rax, %rbx
movl %ebp, 0x10(%rax)
movq %r15, 0x1c0(%rax)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
leaq 0x18(%rax), %r14
movq %r14, %rdi
callq 0x3111
movq 0x8(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x3203
testl %eax, %eax
jne 0x1934
movq %rbx, %rdi
addq $0x190, %rdi            # imm = 0x190
movq %r14, %rsi
xorl %edx, %edx
callq 0x1dac
testl %eax, %eax
jne 0x1953
leaq 0x130(%rip), %rcx       # 0x19b0
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x1972
movq %rax, %rbx
movq %rax, %rdi
addq $0x28, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%rbx)
movb $0x1, 0x150(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%rbx)
movups %xmm0, 0x160(%rbx)
movq %rbx, %rdi
callq 0x3a85
testl %eax, %eax
je 0x1908
leaq 0x37c8(%rip), %rdi      # 0x50aa
leaq 0x379c(%rip), %rsi      # 0x5085
leaq 0x3869(%rip), %rcx      # 0x5159
movl $0xf8, %edx
callq 0x10d0
callq 0x1050
cmpl $0xb, (%rax)
jne 0x1991
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3872(%rip), %rdi      # 0x518e
leaq 0x3762(%rip), %rsi      # 0x5085
leaq 0x382f(%rip), %rcx      # 0x5159
movl $0xe7, %edx
callq 0x10d0
leaq 0x376f(%rip), %rdi      # 0x50aa
leaq 0x3743(%rip), %rsi      # 0x5085
leaq 0x3810(%rip), %rcx      # 0x5159
movl $0xed, %edx
callq 0x10d0
leaq 0x3750(%rip), %rdi      # 0x50aa
leaq 0x3724(%rip), %rsi      # 0x5085
leaq 0x37f1(%rip), %rcx      # 0x5159
movl $0xef, %edx
callq 0x10d0
leaq 0x3917(%rip), %rdi      # 0x5290
leaq 0x3705(%rip), %rsi      # 0x5085
leaq 0x37d2(%rip), %rcx      # 0x5159
movl $0xf2, %edx
callq 0x10d0
leaq 0x3cb3(%rip), %rdi      # 0x564b
leaq 0x36e6(%rip), %rsi      # 0x5085
leaq 0x37b3(%rip), %rcx      # 0x5159
movl $0xdf, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp-test.c
// Function: on_read
static int on_read(struct io_req *req, int len)
{
	struct peer *peer = req->data;
	bool more;
	int err;

	if (len < 0) {
		io_req_put(req);
		list_add_tail(&peer->list, &peer->ctx->peers_to_free);

		return len;
	}

	more = req->flags & REQ_MORE;
	printf("Got: len=%d, more=%d, '%.*s'\n",
	       len, more, len, (char *)req->buf.iov[0].iov_base);
	io_req_put(req);

	if (more) {
		req = io_req_create(&peer->q, REQ_RD, peer, on_read);
		assert(req);
		req->buf = (struct io_buf){
			.iov_num  = 1,
			.is_vari_len = true,
		};
		err = io_queue_submit(req);
		assert(err == 0);

		return len;
	}

	peer->sent = 1;
	req = io_req_create(&peer->q, REQ_WR | REQ_MORE, peer, on_write);
	assert(req);
	req->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = (char *)replies[0],
			.iov_len  = strlen(replies[0])
		},
		.iov_num  = 1,
	};
	err = io_queue_submit(req);
	assert(err == 0);

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movq 0x18(%rdi), %r14
testl %esi, %esi
js 0x1a9c
movl 0x20(%r15), %ebp
andl $0x2, %ebp
movl %ebp, %edx
shrl %edx
movq 0x28(%r15), %r8
leaq 0x37b5(%rip), %rdi      # 0x5193
movl %ebx, %esi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10c0
movq %r15, %rdi
callq 0x3df6
testl %ebp, %ebp
jne 0x1acc
movl $0x1, 0x14(%r14)
leaq 0x18(%r14), %rdi
leaq 0x18c(%rip), %rcx       # 0x1b98
movl $0x3, %esi
movq %r14, %rdx
callq 0x3d60
testq %rax, %rax
je 0x1b3b
movq %rax, %r14
movq 0x66f4(%rip), %r15      # 0x8120
movq %r15, %rdi
callq 0x10a0
movq %r15, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %r14, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x3a85
testl %eax, %eax
je 0x1b2e
leaq 0x3626(%rip), %rdi      # 0x50aa
leaq 0x35fa(%rip), %rsi      # 0x5085
leaq 0x371f(%rip), %rcx      # 0x51b1
movl $0xaa, %edx
callq 0x10d0
movq %r15, %rdi
callq 0x3df6
movq 0x1c0(%r14), %rax
leaq 0x270(%rax), %rcx
movq 0x278(%rax), %rdx
movq %r14, 0x278(%rax)
movq %rcx, (%r14)
movq %rdx, 0x8(%r14)
movq %r14, (%rdx)
jmp 0x1b2e
leaq 0x18(%r14), %rdi
leaq -0x127(%rip), %rcx      # 0x19b0
xorl %esi, %esi
movq %r14, %rdx
callq 0x3d60
testq %rax, %rax
je 0x1b5a
movq %rax, %r14
movq %rax, %rdi
addq $0x28, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r14)
movb $0x1, 0x150(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x3a85
testl %eax, %eax
jne 0x1b79
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x374e(%rip), %rdi      # 0x5290
leaq 0x353c(%rip), %rsi      # 0x5085
leaq 0x3661(%rip), %rcx      # 0x51b1
movl $0xa1, %edx
callq 0x10d0
leaq 0x372f(%rip), %rdi      # 0x5290
leaq 0x351d(%rip), %rsi      # 0x5085
leaq 0x3642(%rip), %rcx      # 0x51b1
movl $0x94, %edx
callq 0x10d0
leaq 0x352a(%rip), %rdi      # 0x50aa
leaq 0x34fe(%rip), %rsi      # 0x5085
leaq 0x3623(%rip), %rcx      # 0x51b1
movl $0x9a, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_recv__REP
static int on_recv__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_queue *q = zmtp->io_proto.q;
	struct io_req *rd_req;
	int exp_len;
	bool more;

	if (len < 0)
		goto out;

	exp_len = zmtp_expect_msg(zmtp, req, false, &more);
	if (exp_len < 0) {
		len = exp_len;
		goto out;
	}
	if (exp_len == 0)
		/* Package is not fully received, continue */
		return 0;

	rd_req = list_first_entry_or_null(&q->queue, struct io_req, list);
	/* Should be checked by on_proto_submit_REP() */
	assert(rd_req);
	assert((rd_req->flags & REQ_RDWR_MASK) == REQ_RD);

	if (!buf_vari_len(&rd_req->buf)) {
		/* Expect exact size if request is not of a variable length */
		if (exp_len != (buf_len(&rd_req->buf) - buf_pos(&rd_req->buf))) {
			len = -EPROTO;
			goto out;
		}
	} else {
		rd_req->buf.__proto.read_hint = exp_len;
	}
	if (more)
		rd_req->flags |= REQ_MORE;

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x20f1
movq (%rbx), %r13
xorl %r12d, %r12d
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2158
movl %eax, %r15d
testl %eax, %eax
js 0x20bb
je 0x2108
movq 0x138(%r13), %rax
addq $0x138, %r13            # imm = 0x138
cmpq %r13, %rax
je 0x211a
movq %rax, %r13
testq %rax, %rax
je 0x211a
testb $0x1, 0x20(%r13)
jne 0x2139
leaq 0x28(%r13), %r12
movq %r12, %rdi
callq 0x29c0
testb %al, %al
je 0x20c0
movl %r15d, %eax
movq %rax, 0x158(%r13)
jmp 0x20e5
movl %r15d, %r12d
jmp 0x20f4
movq %r12, %rdi
callq 0x2aa2
movl %eax, 0x4(%rsp)
movq %r12, %rdi
callq 0x29fb
movl 0x4(%rsp), %ecx
subl %eax, %ecx
movl $0xffffffb9, %r12d      # imm = 0xFFFFFFB9
cmpl %ecx, %r15d
jne 0x20f4
cmpb $0x1, 0x3(%rsp)
jne 0x20f1
orb $0x2, 0x20(%r13)
movl %ebp, %r12d
movq %r14, %rdi
callq 0x3df6
testl %r12d, %r12d
jns 0x2108
movl $0x2, 0x28(%rbx)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x316c(%rip), %rdi      # 0x528d
leaq 0x316c(%rip), %rsi      # 0x5294
leaq 0x316c(%rip), %rcx      # 0x529b
movl $0x9a, %edx
callq 0x10d0
leaq 0x3182(%rip), %rdi      # 0x52c2
leaq 0x314d(%rip), %rsi      # 0x5294
leaq 0x314d(%rip), %rcx      # 0x529b
movl $0x9b, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_1_sign_send__REP
static int on_greet_1_sign_send__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_req *rd_req;
	int rc;

	/*
	 * Signature is sent, recv a peer signature
	 */

	if (len < 0)
		goto out;
	rd_req = io_req_create(zmtp->io_proto.q, REQ_RD, zmtp,
			       on_greet_1_sign_recv__REP);
	if (rd_req == NULL) {
		len = -ENOMEM;
		goto out;
	}
	rd_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_len  = sizeof(sign_and_maj)
		},
		.iov_num  = 1,
	};
	rc = zmtp->io_proto.submit(rd_req, TO_HEAD);
	if (rc) {
		io_req_put(rd_req);
		len = rc;
		goto out;
	}

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x23cf
movq (%rbx), %rdi
leaq 0x92(%rip), %rcx        # 0x23ed
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x23ca
movq %rax, %r15
movq $0x0, 0x28(%rax)
movq $0xb, 0x30(%rax)
movq %rax, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r15)
movups %xmm0, 0x160(%r15)
movq %r15, %rdi
xorl %esi, %esi
callq *0x8(%rbx)
testl %eax, %eax
je 0x23cf
movl %eax, %r12d
movq %r15, %rdi
callq 0x3df6
movl %r12d, %ebp
jmp 0x23cf
movl $0xfffffff4, %ebp       # imm = 0xFFFFFFF4
movq %r14, %rdi
callq 0x3df6
testl %ebp, %ebp
jns 0x23e2
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_1_sign_recv__REP
static int on_greet_1_sign_recv__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct zmtp_header *hdr;
	int rc;

	/*
	 * Peer signature is received, validate and send the rest
	 */

	if (len < 0)
		goto out;

	/* Validate the signature */
	assert(len == sizeof(*hdr));
	hdr = req->buf.iov[0].iov_base;
	if (zmtp_signature_check(&hdr->sign, len)) {
		len = -EMSGSIZE;
		goto out;
	}

	switch (hdr->majv) {
	case 0x01:
		rc = zmtp_greet_v2_rest_send(zmtp);
		break;
	case 0x03:
		rc = zmtp_greet_v3_rest_send(zmtp);
		break;
	default:
		/* TODO: probably reply with some kind of ERROR? */
		len = -EMSGSIZE;
		goto out;
	}
	if (rc < 0)
		len = rc;

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x2510
cmpl $0xb, %ebp
jne 0x2533
movq 0x28(%r14), %rax
movq (%rax), %rcx
xorq 0x5d33(%rip), %rcx      # 0x8150
movzwl 0x8(%rax), %edx
xorw 0x5d30(%rip), %dx       # 0x8158
movzwl %dx, %edx
orq %rcx, %rdx
movl $0xffffffa6, %r15d      # imm = 0xFFFFFFA6
jne 0x2513
movzbl 0xa(%rax), %eax
cmpl $0x3, %eax
je 0x2484
cmpl $0x1, %eax
jne 0x2513
movq (%rbx), %rdi
leaq 0xfc(%rip), %rcx        # 0x2552
movl $0x1, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x2503
movq %rax, %r15
leaq 0x5cf1(%rip), %rax      # 0x8167
movq %rax, 0x28(%r15)
movq $0x3, 0x30(%r15)
jmp 0x24b6
movq (%rbx), %rdi
leaq 0x1e7(%rip), %rcx       # 0x2675
movl $0x1, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x2503
movq %rax, %r15
leaq 0x5cc3(%rip), %rax      # 0x816d
movq %rax, 0x28(%r15)
movq $0x35, 0x30(%r15)
movq %r15, %rdi
addq $0x38, %rdi
xorl %r12d, %r12d
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r15)
movups %xmm0, 0x160(%r15)
movq %r15, %rdi
xorl %esi, %esi
callq *0x8(%rbx)
testl %eax, %eax
je 0x2509
movl %eax, %r12d
movq %r15, %rdi
callq 0x3df6
jmp 0x2509
movl $0xfffffff4, %r12d      # imm = 0xFFFFFFF4
testl %r12d, %r12d
cmovsl %r12d, %ebp
movl %ebp, %r15d
movq %r14, %rdi
callq 0x3df6
testl %r15d, %r15d
jns 0x2527
movl $0x2, 0x28(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e3d(%rip), %rdi      # 0x5377
leaq 0x2d53(%rip), %rsi      # 0x5294
leaq 0x2e43(%rip), %rcx      # 0x538b
movl $0x27e, %edx            # imm = 0x27E
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_v2_2_rest_send__REP
static int on_greet_v2_2_rest_send__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_req *rd_req;
	int rc;

	/*
	 * The rest is send, read the rest from the peer
	 */

	if (len < 0)
		goto out;
	rd_req = io_req_create(zmtp->io_proto.q, REQ_RD, zmtp,
			       on_greet_v2_2_rest_recv__REP);
	if (rd_req == NULL) {
		len = -ENOMEM;
		goto out;
	}
	rd_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_len = sizeof(ZMTP_V2_REQ_HS)
		},
		.iov_num = 1,
	};
	rc = zmtp->io_proto.submit(rd_req, TO_HEAD);
	if (rc) {
		io_req_put(rd_req);
		len = rc;
		goto out;
	}

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x25e5
movq (%rbx), %rdi
leaq 0x92(%rip), %rcx        # 0x2603
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x25e0
movq %rax, %r15
movq $0x0, 0x28(%rax)
movq $0x3, 0x30(%rax)
movq %rax, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r15)
movups %xmm0, 0x160(%r15)
movq %r15, %rdi
xorl %esi, %esi
callq *0x8(%rbx)
testl %eax, %eax
je 0x25e5
movl %eax, %r12d
movq %r15, %rdi
callq 0x3df6
movl %r12d, %ebp
jmp 0x25e5
movl $0xfffffff4, %ebp       # imm = 0xFFFFFFF4
movq %r14, %rdi
callq 0x3df6
testl %ebp, %ebp
jns 0x25f8
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_v2_2_rest_recv__REP
static int on_greet_v2_2_rest_recv__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	void *greet;

	/*
	 * The rest is received, validate version and recv the REQ hshake
	 */

	if (len < 0)
		goto out;

	/* Validate the rest greeting */
	assert(len == sizeof(ZMTP_V2_REQ_HS));
	greet = req->buf.iov[0].iov_base;
	if (memcmp(ZMTP_V2_REQ_HS, greet,  sizeof(ZMTP_V2_REQ_HS))) {
		len = -EMSGSIZE;
		goto out;
	}
out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x18(%rdi), %r14
testl %esi, %esi
js 0x263b
cmpl $0x3, %ebx
jne 0x2656
movq 0x28(%rdi), %rax
movzwl 0x5b49(%rip), %ecx      # 0x816a
xorw (%rax), %cx
movb 0x5b42(%rip), %dl       # 0x816c
xorb 0x2(%rax), %dl
movzbl %dl, %eax
orw %cx, %ax
movl $0xffffffa6, %eax       # imm = 0xFFFFFFA6
cmovnel %eax, %ebx
callq 0x3df6
testl %ebx, %ebx
jns 0x264c
movl $0x2, 0x28(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2d62(%rip), %rdi      # 0x53bf
leaq 0x2c30(%rip), %rsi      # 0x5294
leaq 0x2d72(%rip), %rcx      # 0x53dd
movl $0x220, %edx            # imm = 0x220
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_v3_2_rest_send__REP
static int on_greet_v3_2_rest_send__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_req *rd_req;
	int rc;

	/*
	 * The rest is send, read the rest from the peer
	 */

	if (len < 0)
		goto out;
	rd_req = io_req_create(zmtp->io_proto.q, REQ_RD, zmtp,
			       on_greet_v3_2_rest_recv__REP);
	if (rd_req == NULL) {
		len = -ENOMEM;
		goto out;
	}
	rd_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_len = sizeof(v3_greet)
		},
		.iov_num = 1,
	};
	rc = zmtp->io_proto.submit(rd_req, TO_HEAD);
	if (rc) {
		io_req_put(rd_req);
		len = rc;
		goto out;
	}

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x2708
movq (%rbx), %rdi
leaq 0x92(%rip), %rcx        # 0x2726
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x2703
movq %rax, %r15
movq $0x0, 0x28(%rax)
movq $0x35, 0x30(%rax)
movq %rax, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r15)
movups %xmm0, 0x160(%r15)
movq %r15, %rdi
xorl %esi, %esi
callq *0x8(%rbx)
testl %eax, %eax
je 0x2708
movl %eax, %r12d
movq %r15, %rdi
callq 0x3df6
movl %r12d, %ebp
jmp 0x2708
movl $0xfffffff4, %ebp       # imm = 0xFFFFFFF4
movq %r14, %rdi
callq 0x3df6
testl %ebp, %ebp
jns 0x271b
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq