LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, 0x7394(%rip)      # 0xb3e0
jne 0x40da
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x367a(%rip), %r15      # 0x76e6
cmovneq %rsi, %r15
incl 0x7362(%rip)            # 0xb3d8
movl 0x96e0(%rip), %edx      # 0xd75c
leal 0x1(%rbx), %ecx
leaq 0x39ad(%rip), %rsi      # 0x7a33
leaq 0xc(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2160
movq 0x7334(%rip), %rdi      # 0xb3d0
movq 0x8(%r14), %r8
movswl 0x96a9(%rip), %eax      # 0xd750
movl %eax, (%rsp)
leaq 0x398a(%rip), %rsi      # 0x7a3b
leaq 0x7518(%rip), %rdx      # 0xb5d0
movq %r12, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2110
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6002
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, 0x9727(%rip)      # 0xd808
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3907
movzbl 0x96a8(%rip), %eax      # 0xd810
cmpq $0x3e, %rax
ja 0x4192
movabsq $0x4000000100001200, %rcx # imm = 0x4000000100001200
btq %rax, %rcx
jae 0x4192
movl 0x9680(%rip), %esi      # 0xd804
decl %esi
leaq 0x6f8b(%rip), %rdi      # 0xb118
callq 0x52fe
movslq 0x9673(%rip), %rax      # 0xd80c
leaq 0x95e0(%rip), %rcx      # 0xd780
movb (%rax,%rcx), %al
movb %al, 0x9667(%rip)       # 0xd810
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x955d(%rip), %esi      # 0xd804
movl 0x955f(%rip), %edx      # 0xd80c
leaq 0x9(%rsp), %rbx
movq %rbx, %rdi
callq 0x3fde
movq %rbx, %rdi
callq 0x3ed0
movl 0x953c(%rip), %esi      # 0xd804
movl 0x948e(%rip), %ecx      # 0xd75c
cmpl 0x9494(%rip), %esi      # 0xd768
jne 0x42de
cmpl 0x9490(%rip), %ecx      # 0xd76c
je 0x4318
movslq 0x14(%rax), %rdx
incq %rdx
movl %edx, 0x14(%rax)
movl %esi, 0x947a(%rip)      # 0xd768
movl %ecx, 0x9478(%rip)      # 0xd76c
cmpb $0x0, 0x7046(%rip)      # 0xb341
je 0x4318
cmpl $0x2, 0x70dc(%rip)      # 0xb3e0
jne 0x4318
movq 0x7233(%rip), %rsi      # 0xb540
movslq 0x10(%rax), %rdi
addq %rdx, %rdi
movw %cx, (%rsi,%rdi,2)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x883c(%rip), %edi      # 0xd750
callq 0x5bd0
movzwl 0x8830(%rip), %eax      # 0xd750
movl %eax, %ecx
andl $0x7000, %ecx           # imm = 0x7000
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x881e(%rip)       # 0xd754
orl %ecx, %eax
movw %ax, 0x8811(%rip)       # 0xd750
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4f57
orl %ebx, %ebp
movl %ebp, %ebx
jmp 0x5009
movzwl %bp, %eax
movzwl 0x87f3(%rip), %ecx      # 0xd754
movzwl 0x87ee(%rip), %edx      # 0xd756
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 0x4fcc
btl $0x8, %ebx
jb 0x4fda
cmpb $0x0, 0x63ac(%rip)      # 0xb33a
je 0x4ff0
movzwl 0x87b9(%rip), %edx      # 0xd750
shrl $0x7, %edx
andl $0x1f, %edx
movswl %bp, %esi
leaq 0x66a9(%rip), %rdi      # 0xb650
callq 0x5012
orl %eax, %ebx
orl $0x180, %ebx            # imm = 0x180
movb $0x1, 0x885d(%rip)      # 0xd818
cmpl $0x2, 0x641e(%rip)      # 0xb3e0
jne 0x5009
incl 0x657e(%rip)            # 0xb548
jmp 0x5009
movzbl %bpl, %eax
orl %eax, %ebx
orl $0x80, %ebx
jmp 0x5009
movl 0x8834(%rip), %edx      # 0xd814
leaq 0x61b1(%rip), %rdi      # 0xb198
xorl %esi, %esi
callq 0x4045
jmp 0x5009
movl 0x881e(%rip), %edx      # 0xd814
leaq 0x61ab(%rip), %rdi      # 0xb1a8
xorl %esi, %esi
callq 0x4045
andl $0x7f, %ebp
orl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x60db(%rip)      # 0xb3e0
jne 0x5378
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
incl 0x60bd(%rip)            # 0xb3d8
movl 0x843b(%rip), %edx      # 0xd75c
leal 0x1(%rbx), %ecx
leaq 0x2708(%rip), %rsi      # 0x7a33
leaq 0x4(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2160
movq 0x608f(%rip), %rdi      # 0xb3d0
movq 0x8(%r14), %r8
movswl 0x8403(%rip), %r9d      # 0xd750
leaq 0x2710(%rip), %rsi      # 0x7a64
leaq 0x6275(%rip), %rdx      # 0xb5d0
movq %r15, %rcx
xorl %eax, %eax
callq 0x2110
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6002
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x8489(%rip)      # 0xd808
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8495(%rip), %rax      # 0xd81c
leaq 0x83f2(%rip), %rcx      # 0xd780
addq %rax, %rcx
movzbl (%rcx), %edx
testl %edx, %edx
je 0x53aa
cmpl $0xa, %edx
je 0x53aa
incl %eax
movl %eax, 0x8477(%rip)      # 0xd81c
incq %rcx
jmp 0x5391
movl %eax, 0x8454(%rip)      # 0xd804
movl %eax, 0x8456(%rip)      # 0xd80c
movl %eax, 0x8458(%rip)      # 0xd814
retq
// File: /workspace/github_c_makefile_star2_O2/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: inputDubl
void inputDubl()
{
  WORD32 dublvalue;
  BOOL   scanning_line;

  scanning_line = TRUE;
  do
  {
    while( scanning_line )
    {
      if( isend( line[lexstart] ))
      {
        scanning_line = FALSE;
      }
      else
      {
        switch( line[lexstart] )
        {
        case '/':
          scanning_line = FALSE;
          break;

        case ';':
          nextLexeme();
          break;

        case '+':
          delimiter = line[lexterm];
          nextLexBlank();
        case '-':
        default:
          if( isdigit( line[lexstart] ) || line[lexstart] == '-' )
          {
            dublvalue = getDublExprs();
            punchOutObject( clc, (WORD16)(( dublvalue >> 12 ) & 07777 ));
            incrementClc();
            punchOutObject( clc, (WORD16)( dublvalue & 07777 ));
            incrementClc();
          }
          else
          {
            return;             /* Non-numeric input, back to assembly.       */
          }
          break;
        } /* end switch                                                       */
      } /* end if                                                             */

      if( error_in_line )
      {
        return;                 /* Error occurred, exit DUBL input mode.      */
      }
    } /* end while( scanning_line )                                           */
    readLine();
    nextLexeme();
    scanning_line = TRUE;
  }
  while( TRUE );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb $0x1, %al
leaq 0x83b6(%rip), %r14      # 0xd780
movl $0xfff, %ebp            # imm = 0xFFF
testb %al, %al
jne 0x53e1
callq 0x37fd
callq 0x3907
movb $0x1, %al
jmp 0x53cf
movslq 0x841c(%rip), %rax      # 0xd804
movzbl (%rax,%r14), %ebx
xorl %eax, %eax
testl %ebx, %ebx
je 0x5493
cmpl $0xa, %ebx
je 0x5493
movsbl %bl, %eax
addl $-0x2b, %eax
je 0x541f
rorl %eax
cmpl $0x2, %eax
je 0x541b
cmpl $0x8, %eax
jne 0x5440
callq 0x3907
jmp 0x5491
xorl %eax, %eax
jmp 0x5493
movslq 0x83e6(%rip), %rax      # 0xd80c
movb (%rax,%r14), %al
movb %al, 0x83e0(%rip)       # 0xd810
callq 0x415b
movslq 0x83c8(%rip), %rax      # 0xd804
movb (%rax,%r14), %bl
callq 0x21a0
cmpb $0x2d, %bl
je 0x545c
movq (%rax), %rax
movsbq %bl, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0x54a0
callq 0x54a5
movq %rax, %rbx
movswl 0x82e5(%rip), %edi      # 0xd750
movl %ebx, %esi
shrl $0xc, %esi
andl %ebp, %esi
callq 0x4ed1
callq 0x4f0c
movswl 0x82cd(%rip), %edi      # 0xd750
andl %ebp, %ebx
movl %ebx, %esi
callq 0x4ed1
callq 0x4f0c
movb $0x1, %al
cmpb $0x0, 0x836e(%rip)      # 0xd808
je 0x53cf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movb $0x0, 0x81e6(%rip)      # 0xd824
movslq 0x81c7(%rip), %r13      # 0xd80c
leaq 0x8134(%rip), %r12      # 0xd780
movb (%r13,%r12), %al
movb %al, 0x81b9(%rip)       # 0xd810
movl 0x81a7(%rip), %eax      # 0xd804
leaq 0x5af4(%rip), %rbx      # 0xb158
movslq %eax, %r15
cmpl %r13d, %r15d
jge 0x56b9
callq 0x21a0
movq (%rax), %rcx
movsbq (%r15,%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
je 0x569f
imulq $0xa, %r14, %rcx
addq %rcx, %rax
addq $-0x30, %rax
cmpq %r14, %rax
jge 0x5697
movb $0x1, 0x818d(%rip)      # 0xd824
incq %r15
movq %rax, %r14
jmp 0x5667
movq %rbx, %rdi
movl %r15d, %esi
callq 0x411d
movl 0x815b(%rip), %r13d     # 0xd80c
xorl %r14d, %r14d
movl %r13d, %eax
jmp 0x5664
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x57ac(%rip)     # 0xb404
jl 0x5cae
cmpb $0x0, 0x7b0f(%rip)      # 0xd770
jne 0x5ca0
pushq %rbx
leaq 0x7bd5(%rip), %rbx      # 0xd840
movq %rbx, %rdi
callq 0x20a0
cmpb $0xa, -0x1(%rax,%rbx)
jne 0x5c7f
movb $0x0, -0x1(%rax,%rbx)
leaq 0x7bba(%rip), %rdi      # 0xd840
callq 0x20a0
cmpq $0x40, %rax
popq %rbx
jb 0x5c99
movb $0x0, 0x7be6(%rip)      # 0xd87f
movb $0x1, 0x7ad0(%rip)      # 0xd770
leaq 0x7b99(%rip), %rdi      # 0xd840
xorl %esi, %esi
jmp 0x5caf
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a99(%rip), %ebp      # 0xd760
incl %ebp
movl %ebp, 0x7a91(%rip)      # 0xd760
leaq 0x53eb(%rip), %r15      # 0xb0c1
leaq 0x6(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2070
leaq 0x1d20(%rip), %rsi      # 0x7a0d
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2160
cmpl $0x2, 0x7a5d(%rip)      # 0xd760
jl 0x5d14
movq 0x5824(%rip), %rsi      # 0xb530
pushq $0xc
popq %rdi
callq 0x20d0
movq 0x5815(%rip), %rdi      # 0xb530
leaq 0x1cf1(%rip), %rsi      # 0x7a13
leaq 0x6(%rsp), %rcx
movq %r14, %rdx
xorl %eax, %eax
callq 0x2110
movl $0x3, 0x56c9(%rip)      # 0xb404
movq 0x57ee(%rip), %rax      # 0xb530
testq %rbx, %rbx
je 0x5d5d
leaq 0x1cda(%rip), %rsi      # 0x7a28
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2110
jmp 0x5d68
pushq $0xa
popq %rdi
movq %rax, %rsi
callq 0x20d0
incl 0x5696(%rip)            # 0xb404
movq 0x57bb(%rip), %rsi      # 0xb530
pushq $0xa
popq %rdi
callq 0x20d0
incl 0x5681(%rip)            # 0xb404
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x5798(%rip)      # 0xb530
je 0x5e7f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7b20(%rip), %r12      # 0xd8d0
leaq 0x79c9(%rip), %r13      # 0xd780
pushq $0x9
popq %rbp
pushq $0x20
popq %r14
xorl %ebx, %ebx
movswl %bx, %eax
cmpl %eax, 0x5613(%rip)      # 0xb3dc
jle 0x5e71
callq 0x5c51
movq 0x5755(%rip), %rdi      # 0xb530
movswq %bx, %r15
shlq $0x4, %r15
movq (%r15,%r12), %rdx
leaq 0x1b61(%rip), %rsi      # 0x794f
xorl %eax, %eax
callq 0x2110
movl 0x8(%r15,%r12), %eax
testl %eax, %eax
js 0x5e57
addq %r12, %r15
xorl %r12d, %r12d
movswl %r12w, %ecx
cmpl %ecx, %eax
jle 0x5e31
movswq %r12w, %rax
cmpb $0x9, (%rax,%r13)
movl %ebp, %edi
je 0x5e1c
movl %r14d, %edi
movq 0x570d(%rip), %rsi      # 0xb530
callq 0x20f0
incl %r12d
movl 0x8(%r15), %eax
jmp 0x5e04
movq 0x56f8(%rip), %rsi      # 0xb530
leaq 0x1b19(%rip), %rdi      # 0x7958
callq 0x20c0
incl 0x791a(%rip)            # 0xd764
incl 0x55b4(%rip)            # 0xb404
leaq 0x7a79(%rip), %r12      # 0xd8d0
movq 0x56d2(%rip), %rsi      # 0xb530
leaq 0x1880(%rip), %rdi      # 0x76e5
callq 0x20c0
incl %ebx
jmp 0x5dc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
andl $0x0, 0x5556(%rip)      # 0xb3dc
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %esi, %ebx
cmpb $0x0, 0x54ac(%rip)      # 0xb33d
je 0x5e9b
movswl %di, %edi
callq 0x37e1
movl %ebx, %edi
shrl $0x6, %edi
andl $0x3f, %edi
callq 0x5eb3
andl $0x3f, %ebx
movl %ebx, %edi
popq %rbx
jmp 0x5eb3
// File: /workspace/github_c_makefile_star2_O2/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 0x55e6(%rip), %rsi      # 0xb4a0
testq %rsi, %rsi
je 0x5ed3
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20d0
addw %bx, 0x552e(%rip)       # 0xb400
popq %rbx
movb $0x1, 0x545e(%rip)      # 0xb338
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
decl %r15d
movq 0x54ef(%rip), %r12      # 0xb3e8
pushq $0x2
popq %r13
cmpl %r15d, %r14d
jg 0x5f36
leal (%r15,%r14), %eax
cltd
idivl %r13d
movl %eax, %ebp
cltq
imulq $0x18, %rax, %rax
leaq (%r12,%rax), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jns 0x5f2d
decl %ebp
movl %ebp, %r15d
jmp 0x5efd
je 0x5f3c
incl %ebp
movl %ebp, %r14d
jmp 0x5efd
notl %r14d
movl %r14d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: conditionFalse
void conditionFalse()
{
  int     level;

  if( line[lexstart] == '<' )
  {
    /* Invariant: line[cc] is the next unexamined character.                  */
    level = 1;
    while( level > 0 )
    {
      if( isend( line[cc] ))
      {
        readLine();
      }
      else
      {
        switch( line[cc] )
        {
        case '>':
          level--;
          cc++;
          break;

        case '<':
          level++;
          cc++;
          break;

        case '$':
          level = 0;
          cc++;
          break;

        default:
          cc++;
          break;
        } /* end switch                                                       */
      } /* end if                                                             */
    } /* end while                                                            */
    nextLexeme();
  }
  else
  {
    errorMessage( &lt_expected, lexstart );
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movslq 0x787b(%rip), %rsi      # 0xd804
leaq 0x77f0(%rip), %rbx      # 0xd780
cmpb $0x3c, (%rsi,%rbx)
jne 0x5ff0
pushq $0x1
popq %rbp
testl %ebp, %ebp
jle 0x5fe5
movslq 0x7878(%rip), %rax      # 0xd81c
movzbl (%rax,%rbx), %ecx
testl %ecx, %ecx
je 0x5fca
cmpl $0xa, %ecx
je 0x5fca
cmpl $0x24, %ecx
je 0x5fd1
cmpl $0x3c, %ecx
je 0x5fe1
cmpl $0x3e, %ecx
je 0x5fdd
incl %eax
movl %eax, 0x7854(%rip)      # 0xd81c
jmp 0x5f99
callq 0x37fd
jmp 0x5f99
incl %eax
movl %eax, 0x7843(%rip)      # 0xd81c
xorl %ebp, %ebp
jmp 0x5f99
decl %ebp
jmp 0x5fc0
incl %ebp
jmp 0x5fc0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3907
leaq 0x52c1(%rip), %rdi      # 0xb2b8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x52fe
// File: /workspace/github_c_makefile_star2_O2/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 0x53d4(%rip), %eax      # 0xb3dc
cmpq $0x13, %rax
ja 0x602c
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x78b4(%rip), %rdx      # 0xd8d0
movq %rdi, (%rcx,%rdx)
movl %esi, 0x8(%rcx,%rdx)
incl %eax
movl %eax, 0x53b0(%rip)      # 0xb3dc
movb $0x1, 0x77d5(%rip)      # 0xd808
cmpb $0x0, 0x771e(%rip)      # 0xd758
jne 0x5d90
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq 0x2e5a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1040
testl %eax, %eax
jne 0x11ff
pushq $0x48
popq %rdi
callq 0x1030
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x1070
pushq $0x45
popq %rdi
callq 0x1030
movl %ebx, %edi
callq 0x1070
pushq $0x4c
popq %rbp
movl %ebp, %edi
callq 0x1030
movl %ebx, %edi
callq 0x1070
movl %ebp, %edi
callq 0x1030
movl %ebx, %edi
callq 0x1070
pushq $0x4f
popq %rdi
callq 0x1030
movl %ebx, %edi
callq 0x1070
pushq $0xa
popq %rdi
callq 0x1030
movl %ebx, %edi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdfe(%rip), %rdi       # 0x2004
callq 0x1050
pushq $0x1
popq %rdi
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x88, %rsp
movl (%rsi), %edi
leaq 0x8(%rsp), %rsi
movl $0x80, %edx
callq 0x1130
testq %rax, %rax
js 0x1719
cmpq $0x80, %rax
jne 0x1730
pushq $0x1
popq %rax
movl 0x8(%rsp), %ecx
cmpl $0x2, %ecx
je 0x1728
cmpl $0xf, %ecx
je 0x1728
leaq 0x3f2a(%rip), %rdi      # 0x562b
leaq 0x395d(%rip), %rsi      # 0x5065
leaq 0x39fe(%rip), %rcx      # 0x510d
movl $0xc5, %edx
callq 0x10d0
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
jne 0x1730
addq $0x88, %rsp
retq
leaq 0x3ef4(%rip), %rdi      # 0x562b
leaq 0x3927(%rip), %rsi      # 0x5065
leaq 0x39c8(%rip), %rcx      # 0x510d
movl $0xbb, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x1869
movl %eax, %ebp
movl $0x1c8, %edi            # imm = 0x1C8
callq 0x1180
testq %rax, %rax
je 0x1884
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 0x2cc7
movq 0x8(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2db6
testl %eax, %eax
jne 0x18a3
movq %rbx, %rdi
addq $0x190, %rdi            # imm = 0x190
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d04
testl %eax, %eax
jne 0x18c2
leaq 0x130(%rip), %rcx       # 0x191f
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x18e1
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 0x3515
testl %eax, %eax
je 0x1877
leaq 0x3839(%rip), %rdi      # 0x508a
leaq 0x380d(%rip), %rsi      # 0x5065
leaq 0x38da(%rip), %rcx      # 0x5139
movl $0xf8, %edx
callq 0x10d0
callq 0x1050
cmpl $0xb, (%rax)
jne 0x1900
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38e3(%rip), %rdi      # 0x516e
leaq 0x37d3(%rip), %rsi      # 0x5065
leaq 0x38a0(%rip), %rcx      # 0x5139
movl $0xe7, %edx
callq 0x10d0
leaq 0x37e0(%rip), %rdi      # 0x508a
leaq 0x37b4(%rip), %rsi      # 0x5065
leaq 0x3881(%rip), %rcx      # 0x5139
movl $0xed, %edx
callq 0x10d0
leaq 0x37c1(%rip), %rdi      # 0x508a
leaq 0x3795(%rip), %rsi      # 0x5065
leaq 0x3862(%rip), %rcx      # 0x5139
movl $0xef, %edx
callq 0x10d0
leaq 0x3988(%rip), %rdi      # 0x5270
leaq 0x3776(%rip), %rsi      # 0x5065
leaq 0x3843(%rip), %rcx      # 0x5139
movl $0xf2, %edx
callq 0x10d0
leaq 0x3d24(%rip), %rdi      # 0x562b
leaq 0x3757(%rip), %rsi      # 0x5065
leaq 0x3824(%rip), %rcx      # 0x5139
movl $0xdf, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x1a09
movl 0x20(%r15), %ebp
andl $0x2, %ebp
movl %ebp, %edx
shrl %edx
movq 0x28(%r15), %r8
leaq 0x3826(%rip), %rdi      # 0x5173
movl %ebx, %esi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10c0
movq %r15, %rdi
callq 0x3833
testl %ebp, %ebp
jne 0x1a39
movl $0x1, 0x14(%r14)
leaq 0x18(%r14), %rdi
leaq 0x18a(%rip), %rcx       # 0x1b05
pushq $0x3
popq %rsi
movq %r14, %rdx
callq 0x37a0
testq %rax, %rax
je 0x1aa8
movq %rax, %r14
movq 0x6787(%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 0x3515
testl %eax, %eax
je 0x1a9b
leaq 0x3699(%rip), %rdi      # 0x508a
leaq 0x366d(%rip), %rsi      # 0x5065
leaq 0x3792(%rip), %rcx      # 0x5191
movl $0xaa, %edx
callq 0x10d0
movq %r15, %rdi
callq 0x3833
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 0x1a9b
leaq 0x18(%r14), %rdi
leaq -0x125(%rip), %rcx      # 0x191f
xorl %esi, %esi
movq %r14, %rdx
callq 0x37a0
testq %rax, %rax
je 0x1ac7
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 0x3515
testl %eax, %eax
jne 0x1ae6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37c1(%rip), %rdi      # 0x5270
leaq 0x35af(%rip), %rsi      # 0x5065
leaq 0x36d4(%rip), %rcx      # 0x5191
movl $0xa1, %edx
callq 0x10d0
leaq 0x37a2(%rip), %rdi      # 0x5270
leaq 0x3590(%rip), %rsi      # 0x5065
leaq 0x36b5(%rip), %rcx      # 0x5191
movl $0x94, %edx
callq 0x10d0
leaq 0x359d(%rip), %rdi      # 0x508a
leaq 0x3571(%rip), %rsi      # 0x5065
leaq 0x3696(%rip), %rcx      # 0x5191
movl $0x9a, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/rouming[P]io/zmtp.c
// Function: on_proto_submit_REP
static int on_proto_submit_REP(struct io_proto *p, struct io_req *req)
{
	struct io_req *hdr_req;
	struct zmtp *zmtp;
	int rc;

	zmtp = container_of(p, struct zmtp, io_proto);
	if (zmtp->inner_state == ZMTP_REP_CLOSED)
		/* That's all folks */
		return -ENOTCONN;

	if (req->flags & REQ_WR)
		hdr_req = zmtp_create_wr_hdr_req(zmtp, req);
	else
		hdr_req = zmtp_create_rd_hdr_req(zmtp);

	if (hdr_req == NULL)
		return -ENOMEM;

	rc = zmtp->io_proto.submit(hdr_req, TO_TAIL);
	if (rc)
		return rc;

	if (zmtp->inner_state == ZMTP_UNKNOWN)
		/* Start greeting */
		return zmtp_start_greeting_REP(zmtp);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, 0x28(%rdi)
jne 0x1d54
pushq $-0x6b
popq %rbp
jmp 0x1f0c
movq %rsi, %r15
movq %rdi, %rbx
testb $0x1, 0x20(%rsi)
movq (%rdi), %rdi
pushq $-0xc
popq %r12
jne 0x1d94
leaq 0x1be(%rip), %rcx       # 0x1f2c
xorl %esi, %esi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x1f09
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2050
jmp 0x1e68
leaq 0x185(%rip), %rcx       # 0x1f20
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x1f09
movq %rax, %r14
leaq 0x28(%r15), %rdi
callq 0x28df
cmpb $0x0, 0x2c(%rbx)
jne 0x1de3
movb $0x1, 0x2c(%rbx)
leaq 0x638e(%rip), %rcx      # 0x815a
movq %rcx, 0x28(%r14)
movq $0x2, 0x30(%r14)
movq $0x1, 0x148(%r14)
movl 0x20(%r15), %ecx
testb $0x2, %cl
jne 0x1df0
movb $0x0, 0x2c(%rbx)
xorl %edx, %edx
cmpl $0x100, %eax            # imm = 0x100
setge %dl
movl %eax, %esi
bswapq %rsi
movzbl %al, %eax
cmovlq %rax, %rsi
pushq $0x8
popq %rax
pushq $0x1
popq %rdi
cmovgeq %rax, %rdi
leaq 0x160(%r14), %rax
movq %rsi, 0x160(%r14)
movq %r14, %rsi
addq $0x161, %rsi            # imm = 0x161
shrl %ecx
andl $0x1, %ecx
leal (%rcx,%rdx,2), %ecx
movb %cl, 0x161(%r14)
movq 0x148(%r14), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq %rsi, 0x28(%r14,%rdx)
movq $0x1, 0x30(%r14,%rdx)
movq %rax, 0x38(%r14,%rdx)
movq %rdi, 0x40(%r14,%rdx)
addq $0x2, %rcx
movq %rcx, 0x148(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq *0x8(%rbx)
movl %eax, %ebp
testl %eax, %eax
jne 0x1f0c
xorl %ebp, %ebp
cmpl $0x0, 0x28(%rbx)
jne 0x1f0c
movq (%rbx), %rdi
leaq 0x37e(%rip), %rcx       # 0x220f
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x37a0
movl %r12d, %ebp
testq %rax, %rax
je 0x1f0c
movq %rax, %r14
leaq 0x62ae(%rip), %rax      # 0x815c
movq %rax, 0x28(%r14)
movq $0xb, 0x30(%r14)
movq %r14, %rdi
addq $0x38, %rdi
xorl %ebp, %ebp
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
xorl %esi, %esi
callq *0x8(%rbx)
testl %eax, %eax
je 0x1f17
movl %eax, %r15d
movq %r14, %rdi
callq 0x3833
movl %r15d, %ebp
jmp 0x1f0c
movl %r12d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, 0x28(%rbx)
jmp 0x1f0c
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rdi, %r15
movq 0x18(%rdi), %r14
testl %esi, %esi
js 0x1fe9
movq (%r14), %r13
xorl %r12d, %r12d
leaq 0x3(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x20a3
movl %eax, %ebp
testl %eax, %eax
js 0x1fb5
je 0x2000
movq 0x138(%r13), %r12
addq $0x138, %r13            # imm = 0x138
cmpq %r13, %r12
je 0x2012
testq %r12, %r12
je 0x2012
testb $0x1, 0x20(%r12)
jne 0x2031
leaq 0x28(%r12), %r13
movq %r13, %rdi
callq 0x2828
testb %al, %al
je 0x1fb9
movl %ebp, %eax
movq %rax, 0x158(%r12)
jmp 0x1fd7
movl %ebp, %ebx
jmp 0x1fe9
movq %r13, %rdi
callq 0x28df
movl %eax, 0x4(%rsp)
movq %r13, %rdi
callq 0x286c
movl 0x4(%rsp), %ecx
subl %eax, %ecx
cmpl %ecx, %ebp
jne 0x1fe6
cmpb $0x1, 0x3(%rsp)
jne 0x1fe9
orb $0x2, 0x20(%r12)
jmp 0x1fe9
pushq $-0x47
popq %rbx
movq %r15, %rdi
callq 0x3833
testl %ebx, %ebx
jns 0x1ffd
movl $0x2, 0x28(%r14)
movl %ebx, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3254(%rip), %rdi      # 0x526d
leaq 0x3254(%rip), %rsi      # 0x5274
leaq 0x3254(%rip), %rcx      # 0x527b
movl $0x9a, %edx
callq 0x10d0
leaq 0x326a(%rip), %rdi      # 0x52a2
leaq 0x3235(%rip), %rsi      # 0x5274
leaq 0x3235(%rip), %rcx      # 0x527b
movl $0x9b, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x229d
movq (%rbx), %rdi
leaq 0x8d(%rip), %rcx        # 0x22bb
xorl %esi, %esi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x229a
movq %rax, %r15
andq $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 0x229d
movl %eax, %r12d
movq %r15, %rdi
callq 0x3833
movl %r12d, %ebp
jmp 0x229d
pushq $-0xc
popq %rbp
movq %r14, %rdi
callq 0x3833
testl %ebp, %ebp
jns 0x22b0
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x22f2
cmpl $0xb, %ebp
jne 0x23f5
movq 0x28(%r14), %r15
pushq $0xb
popq %rsi
movq %r15, %rdi
callq 0x1cdc
pushq $-0x5a
popq %rbp
testl %eax, %eax
je 0x2316
movq %r14, %rdi
callq 0x3833
testl %ebp, %ebp
jns 0x2305
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl 0xa(%r15), %eax
pushq $0xb
popq %r13
cmpl $0x3, %eax
je 0x235f
cmpl $0x1, %eax
jne 0x22f2
movq (%rbx), %rdi
leaq 0xe1(%rip), %rcx        # 0x2414
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x23ed
movq %rax, %r15
leaq 0x5e16(%rip), %rax      # 0x8167
movq %rax, 0x28(%r15)
movq $0x3, 0x30(%r15)
jmp 0x238f
movq (%rbx), %rdi
leaq 0x1c5(%rip), %rcx       # 0x252e
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x23ed
movq %rax, %r15
leaq 0x5dea(%rip), %rax      # 0x816d
movq %rax, 0x28(%r15)
movq $0x35, 0x30(%r15)
movq %r15, %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)
movl %r13d, %ebp
testl %eax, %eax
je 0x22f2
movl %eax, %r12d
movq %r15, %rdi
callq 0x3833
testl %r12d, %r12d
pushq $0xb
popq %rbp
cmovsl %r12d, %ebp
jmp 0x22f2
pushq $-0xc
popq %rbp
jmp 0x22f2
leaq 0x2f5b(%rip), %rdi      # 0x5357
leaq 0x2e71(%rip), %rsi      # 0x5274
leaq 0x2f61(%rip), %rcx      # 0x536b
movl $0x27e, %edx            # imm = 0x27E
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x24a2
movq (%rbx), %rdi
leaq 0x8d(%rip), %rcx        # 0x24c0
xorl %esi, %esi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x249f
movq %rax, %r15
andq $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 0x24a2
movl %eax, %r12d
movq %r15, %rdi
callq 0x3833
movl %r12d, %ebp
jmp 0x24a2
pushq $-0xc
popq %rbp
movq %r14, %rdi
callq 0x3833
testl %ebp, %ebp
jns 0x24b5
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
testl %esi, %esi
js 0x24f4
cmpl $0x3, %ebp
jne 0x250f
movq 0x28(%rbx), %rsi
leaq 0x5c89(%rip), %rdi      # 0x816a
pushq $0x3
popq %rdx
callq 0x11a0
testl %eax, %eax
pushq $0x3
popq %rax
pushq $-0x5a
popq %rbp
cmovel %eax, %ebp
movq %rbx, %rdi
callq 0x3833
testl %ebp, %ebp
jns 0x2508
movl $0x2, 0x28(%r14)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2e89(%rip), %rdi      # 0x539f
leaq 0x2d57(%rip), %rsi      # 0x5274
leaq 0x2e99(%rip), %rcx      # 0x53bd
movl $0x220, %edx            # imm = 0x220
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x25bc
movq (%rbx), %rdi
leaq 0x8d(%rip), %rcx        # 0x25da
xorl %esi, %esi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x25b9
movq %rax, %r15
andq $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 0x25bc
movl %eax, %r12d
movq %r15, %rdi
callq 0x3833
movl %r12d, %ebp
jmp 0x25bc
pushq $-0xc
popq %rbp
movq %r14, %rdi
callq 0x3833
testl %ebp, %ebp
jns 0x25cf
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rouming[P]io/zmtp.c
// Function: on_greet_v3_2_rest_recv__REP
static int on_greet_v3_2_rest_recv__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_req *rd_req;
	struct zmtp_greeting_v3 *greet;
	int rc;

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

	if (len < 0)
		goto out;

	/* Validate the rest greeting */
	assert(len == sizeof(*greet));
	greet = req->buf.iov[0].iov_base;
	if (memcmp(&v3_greet, greet,  sizeof(*greet))) {
		len = -EMSGSIZE;
		goto out;
	}

	rd_req = io_req_create(zmtp->io_proto.q, REQ_RD, zmtp,
			       on_greet_v3_3_hshake_recv__REP);
	if (rd_req == NULL) {
		len = -ENOMEM;
		goto out;
	}
	/*
	 * TODO: probably we need generic function for that,
	 * TODO: like zmtp_init_rd_hdr_req() already does.
	 */
	rd_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_len  = 1 /* Flag field to determin the size */
		},
		.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 0x2612
cmpl $0x35, %ebp
jne 0x26af
movq 0x28(%r14), %rsi
leaq 0x5b6a(%rip), %rdi      # 0x816d
pushq $0x35
popq %rdx
callq 0x11a0
testl %eax, %eax
je 0x2630
pushq $-0x5a
popq %rbp
movq %r14, %rdi
callq 0x3833
testl %ebp, %ebp
jns 0x2625
movl $0x2, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0x94(%rip), %rcx        # 0x26ce
xorl %esi, %esi
movq %rbx, %rdx
callq 0x37a0
testq %rax, %rax
je 0x26a1
movq %rax, %r15
andq $0x0, 0x28(%rax)
pushq $0x1
popq %r12
movq %r12, 0x30(%rax)
movq %rax, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq %r12, 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 0x26a8
movl %eax, %ebp
movq %r15, %rdi
callq 0x3833
jmp 0x2612
pushq $-0xc
jmp 0x2611
pushq $0x35
jmp 0x2611
leaq 0x2d3e(%rip), %rdi      # 0x53f4
leaq 0x2bb7(%rip), %rsi      # 0x5274
leaq 0x2d46(%rip), %rcx      # 0x540a
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x10d0