LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_tagorder_offset_sort
int *otf_tagorder_offset_sort(const OTF_FILE *otf) // {{{
{
  int *order=malloc(sizeof(int)*otf->numTables);
  if (!order) {
    fprintf(stderr,"Bad alloc: %s\n", strerror(errno));
    return NULL;
  }

  int iA;
  struct _OTF_KV tmp[otf->numTables]; // or tmp=malloc(sizeof(struct _OTF_KV)*otf->numTables); assert(tmp);
  for (iA=0;iA<otf->numTables;iA++) {
    tmp[iA].key=otf->tables[iA].offset;
    tmp[iA].value=iA;
  }
  qsort(tmp,otf->numTables,sizeof(struct _OTF_KV),otf_kv_compare); // qsort_r / qsort_s makes portability hard ...
  for (iA=0;iA<otf->numTables;iA++) {
    order[iA]=tmp[iA].value;
  }
  return order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x38(%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbea6
movq 0x716f(%rip), %rax      # 0x12fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x2070
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x24ca(%rip), %rsi      # 0xe35c
movb $0x0, %al
callq 0x21e0
movq $0x0, -0x8(%rbp)
jmp 0xbf89
movq -0x10(%rbp), %rax
movzwl 0x38(%rax), %edx
movl %edx, %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movl %edx, %ecx
leal 0xf(,%rcx,8), %ecx
andl $-0x10, %ecx
movl %ecx, %edx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x38(%rcx), %ecx
cmpl %ecx, %eax
jge 0xbf23
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x14, %rdx, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movl -0x1c(%rbp), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbedd
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x38(%rax), %eax
movl %eax, %esi
movl $0x8, %edx
leaq 0x63(%rip), %rcx        # 0xbfa0
callq 0x2250
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x38(%rcx), %ecx
cmpl %ecx, %eax
jge 0xbf7a
movq -0x40(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbf49
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq -0x8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_kv_compare
static int otf_kv_compare(const void *a,const void *b) // {{{
{
  const unsigned int aa=((const struct _OTF_KV *)a)->key;
  const unsigned int bb=((const struct _OTF_KV *)b)->key;
  if (aa<bb) {
    return -1;
  } else if (aa>bb) {
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xbfcf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbfe9
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0xbfe0
movl $0x1, -0x4(%rbp)
jmp 0xbfe9
jmp 0xbfe2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_action_copy
void otf_action_copy(struct _OTF_WRITE_TABLE *self) // {{{
{
  OTF_FILE *otf=self->copy.otf;
  const OTF_DIRENT *table=otf->tables+self->copy.table_no;

  // get checksum and unpadded length
  self->info.table.tag=self->tag;
  self->info.table.checkSum=table->checkSum;
  self->info.table.offset=0; // later
  self->info.table.length=table->length; // unpadded
  self->info.table.compLength=table->length; // uncompressed

  self->info.data=NULL;
  self->info.load=action_copy_load;
  self->info.free=action_free;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0x15(%rip), %rcx        # 0xc090
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0xa6(%rip), %rcx        # 0xc130
movq %rcx, 0x48(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: action_copy_load
static int action_copy_load(struct _OTF_WRITE_TABLE *self) // {{{
{
  OTF_FILE *otf=self->copy.otf;
  const OTF_DIRENT *table=otf->tables+self->copy.table_no;

  char *data=otf_read_table(otf,NULL,table);
  if (!data) {
    return -1;
  }

  assert(!self->info.data);
  self->info.data=data;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2e90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc0e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc127
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xc0f5
jmp 0xc114
leaq 0x3b2a(%rip), %rdi      # 0xfc26
leaq 0x3a4a(%rip), %rsi      # 0xfb4d
movl $0xbc, %edx
leaq 0x3b28(%rip), %rcx      # 0xfc37
callq 0x2100
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_action_replace
void otf_action_replace(struct _OTF_WRITE_TABLE *self) // {{{
{
  char *data=self->replace.data;
  int length=self->replace.length;

  // get checksum and unpadded length
  self->info.table.tag=self->tag;
  self->info.table.checkSum=otf_checksum(data,otf_padded(length));
  self->info.table.offset=0; // later
  self->info.table.length=length; // unpadded
  self->info.table.compLength=length; // uncompressed

  assert(data);
  if (otf_padded(length)>length) { // clear padding bytes
    memset(data+length,0,otf_padded(length)-length);
  }
  self->info.data=data;
  self->info.load=NULL;
  self->info.free=action_nop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0xc2f0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xc290
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xc20e
jmp 0xc22d
leaq 0x3a1d(%rip), %rdi      # 0xfc32
leaq 0x3931(%rip), %rsi      # 0xfb4d
movl $0x104, %edx            # imm = 0x104
leaq 0x3932(%rip), %rcx      # 0xfb5a
callq 0x2100
movl -0x14(%rbp), %edi
callq 0xc2f0
cmpl -0x14(%rbp), %eax
jle 0xc262
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0xc2f0
movq -0x28(%rbp), %rdi
subl -0x14(%rbp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x20e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x8b(%rip), %rcx        # 0xc310
movq %rcx, 0x48(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_write_header
static int otf_write_header(const struct _OTF_WRITE_INFO *otw,char *out) // {{{
{
  // header
  set_ULONG(out,otw->version);
  set_USHORT(out+4,otw->numTables);
  int a,b,c;
  otf_bsearch_params(otw->numTables,16,&a,&b,&c);
  set_USHORT(out+6,a);
  set_USHORT(out+8,b);
  set_USHORT(out+10,c);

  // directory
  int ret=12,iA;
  for (iA=0;iA<otw->numTables;iA++) {
    const OTF_DIRENT *table=&otw->tables[iA].info.table;

    set_ULONG(out+ret,table->tag);
    set_ULONG(out+ret+4,table->checkSum);
    set_ULONG(out+ret+8,table->offset);
    set_ULONG(out+ret+12,table->length);
    ret+=16;
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0xca00
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %esi
callq 0xd000
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %edi
movl $0x10, %esi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0xd040
movq -0x10(%rbp), %rdi
addq $0x6, %rdi
movl -0x14(%rbp), %eax
movzwl %ax, %esi
callq 0xd000
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %eax
movzwl %ax, %esi
callq 0xd000
movq -0x10(%rbp), %rdi
addq $0xa, %rdi
movl -0x1c(%rbp), %eax
movzwl %ax, %esi
callq 0xd000
movl $0xc, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jge 0xc959
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
addq $0x20, %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0xca00
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
addq $0x4, %rdi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xca00
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xca00
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xca00
movl -0x20(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc8a9
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: action_load_data
static int action_load_data(struct _OTF_WRITE_TABLE *self) // {{{
{
  if (!self->info.data) {
    assert(self->info.load);
    if (!self->info.load) {
      return -1;
    }
    const int res=(*self->info.load)(self);
    if (res<0) {
      return -1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xc9e9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xc994
jmp 0xc9b3
leaq 0x335f(%rip), %rdi      # 0xfcfa
leaq 0x31ab(%rip), %rsi      # 0xfb4d
movl $0xd9, %edx
leaq 0x335c(%rip), %rcx      # 0xfd0a
callq 0x2100
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xc9c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9f0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xc9e7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9f0
jmp 0xc9e9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: action_hlp_compress
static int action_hlp_compress(struct _OTF_WRITE_TABLE *self) // {{{
{
  unsigned long compLength;
  char *comp=otf_write_compressed_raw(self->info.data,self->info.table.length,&compLength);
  if (comp) { // compressed
    (*self->info.free)(self);
    if (otf_padded(compLength)>compLength) { // clear padding bytes
      memset(comp+compLength,0,otf_padded(compLength)-compLength);
    }
    self->info.data=comp;
    self->info.table.compLength=compLength;
    self->info.free=action_free;
  } else if (compLength==-1) { // error
    (*self->info.free)(self);
    return -1;
  } // else: leave uncompressed
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x34(%rax), %esi
leaq -0x18(%rbp), %rdx
callq 0xd160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcb03
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0xc2f0
cltq
cmpq -0x18(%rbp), %rax
jbe 0xcad9
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0xc2f0
movq -0x28(%rbp), %rdi
movslq %eax, %rdx
subq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x20e0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq -0x9cd(%rip), %rcx      # 0xc130
movq %rcx, 0x48(%rax)
jmp 0xcb23
cmpq $-0x1, -0x18(%rbp)
jne 0xcb21
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcb2a
jmp 0xcb23
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_prepare_woff_header
static int otf_prepare_woff_header(OTF_WOFF_HEADER *hdr,struct _OTF_WRITE_WOFF *woff,unsigned int origLength,unsigned int sfntCompLength) // {{{
{
  hdr->origLength=origLength;
  hdr->majorVersion=woff->majorVersion;
  hdr->minorVersion=woff->minorVersion;

  if ( (woff->metaData)&&(woff->metaLength>0) ) {
    unsigned long compLength;
    woff->metaCompData=otf_write_compressed_raw(woff->metaData,woff->metaLength,&compLength);
    if ( (!woff->metaCompData)&&(compLength==-1) ) { // error
      return -1;
    }
    hdr->metaOffset=sfntCompLength;
    hdr->metaLength=compLength;
    hdr->metaOrigLength=woff->metaLength;
  } else {
    hdr->metaOffset=0;
    hdr->metaLength=0;
    hdr->metaOrigLength=0;
  }
  if ( (woff->privData)&&(woff->privLength>0) ) {
    hdr->privOffset=sfntCompLength+otf_padded(hdr->metaLength);
    hdr->privLength=woff->privLength;
  } else {
    hdr->privOffset=0;
    hdr->privLength=0;
  }

  hdr->length=sfntCompLength+otf_padded(hdr->metaLength)+hdr->privLength;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movw (%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
movw 0x2(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcbfc
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jbe 0xcbfc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
leaq -0x28(%rbp), %rdx
callq 0xd160
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xcbd5
cmpq $-0x1, -0x28(%rbp)
jne 0xcbd5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcca1
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xcc1d
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xcc60
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jbe 0xcc60
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0xc2f0
movl -0x2c(%rbp), %ecx
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0xcc76
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0xc2f0
movl -0x30(%rbp), %ecx
addl %eax, %ecx
movq -0x10(%rbp), %rax
addl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_write_woff_footer
static int otf_write_woff_footer(struct _OTF_WRITE_WOFF *woff,OUTPUT_FN output,void *context) // {{{
{
  int ret=0;
  if (woff->metaCompData) {
    (*output)(woff->metaCompData,woff->metaLength,context);
    ret+=woff->metaLength;
  } else if (woff->metaData) {
    (*output)(woff->metaData,woff->metaLength,context);
    ret+=woff->metaLength;
  }
  const int extrapad=otf_padded(woff->metaLength)-woff->metaLength;
  if (extrapad) {
    const char pad[4]={0,0,0,0};
    (*output)(pad,extrapad,context);
    ret+=extrapad;
  }
  if (woff->privData) {
    (*output)(woff->privData,woff->privLength,context);
    ret+=woff->privLength;
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xcefe
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xcf31
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcf2f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xcf31
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0xc2f0
movq -0x8(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xcf77
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x20e0
movq -0x10(%rbp), %rax
leaq -0x24(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xcfa8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_bsearch_params
static void otf_bsearch_params(int num, // {{{
                               int recordSize,
                               int *searchRange,
                               int *entrySelector,
                               int *rangeShift)
{
  assert(num>0);
  assert(searchRange);
  assert(entrySelector);
  assert(rangeShift);

  int iA,iB;
  for (iA=1,iB=0;iA<=num;iA<<=1,iB++) {}

  *searchRange=iA*recordSize/2;
  *entrySelector=iB-1;
  *rangeShift=num*recordSize-*searchRange;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xd062
jmp 0xd081
leaq 0x2c2f(%rip), %rdi      # 0xfc98
leaq 0x2add(%rip), %rsi      # 0xfb4d
movl $0x12, %edx
leaq 0x2c22(%rip), %rcx      # 0xfc9e
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0xd08a
jmp 0xd0a9
leaq 0x2c44(%rip), %rdi      # 0xfcd5
leaq 0x2ab5(%rip), %rsi      # 0xfb4d
movl $0x13, %edx
leaq 0x2bfa(%rip), %rcx      # 0xfc9e
callq 0x2100
cmpq $0x0, -0x18(%rbp)
je 0xd0b2
jmp 0xd0d1
leaq 0x2c28(%rip), %rdi      # 0xfce1
leaq 0x2a8d(%rip), %rsi      # 0xfb4d
movl $0x14, %edx
leaq 0x2bd2(%rip), %rcx      # 0xfc9e
callq 0x2100
cmpq $0x0, -0x20(%rbp)
je 0xd0da
jmp 0xd0f9
leaq 0x2c0e(%rip), %rdi      # 0xfcef
leaq 0x2a65(%rip), %rsi      # 0xfb4d
movl $0x15, %edx
leaq 0x2baa(%rip), %rcx      # 0xfc9e
callq 0x2100
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0xd124
jmp 0xd111
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd107
movl -0x24(%rbp), %eax
imull -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
imull -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
subl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/sfnt_write.c
// Function: otf_write_compressed_raw
static char *otf_write_compressed_raw(const char *in,unsigned int length,unsigned long *compLength) // {{{
{
  assert(compLength);
#ifdef WOFF_SUPPORT
  *compLength=compressBound(length); // known to be > otf_padded(length)
  char *tmp=malloc(sizeof(char)*(*compLength));
  if (!tmp) {
    fprintf(stderr,"Bad alloc: %s\n", strerror(errno));
    *compLength=-1;
    return NULL;
  }
  if (compress2((unsigned char *)tmp,compLength,(const unsigned char *)in,length,9)!=Z_OK) {
    fprintf(stderr,"Compression failed\n");
    free(tmp);
    *compLength=-1;
    return NULL;
  }
  if (*compLength<length) {
    return tmp; // compressed
  }
  free(tmp);
#endif
  *compLength=length; // uncompressed
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd17c
jmp 0xd19b
leaq 0x2bb7(%rip), %rdi      # 0xfd3a
leaq 0x29c3(%rip), %rsi      # 0xfb4d
movl $0x22, %edx
leaq 0x2baf(%rip), %rcx      # 0xfd45
callq 0x2100
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x2210
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0x21d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd211
movq 0x5e0f(%rip), %rax      # 0x12fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x2070
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x116a(%rip), %rsi      # 0xe35c
movb $0x0, %al
callq 0x21e0
movq -0x20(%rbp), %rax
movq $-0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xd29e
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %eax
movl %eax, %ecx
movl $0x9, %r8d
callq 0x20d0
cmpl $0x0, %eax
je 0xd268
movq 0x5da7(%rip), %rax      # 0x12fe0
movq (%rax), %rdi
leaq 0x2b4e(%rip), %rsi      # 0xfd91
movb $0x0, %al
callq 0x21e0
movq -0x28(%rbp), %rdi
callq 0x21b0
movq -0x20(%rbp), %rax
movq $-0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xd29e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0xd281
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd29e
movq -0x28(%rbp), %rdi
callq 0x21b0
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/./plugins/dummy_bad4/../dummy/plugin_dummy.c
// Function: sir_plugin_query
PLUGIN_EXPORT bool sir_plugin_query(sir_plugininfo* info) {
#if defined(PLUGINDUMMY_BADBEHAVIOR2)
    info->iface_ver = 255U;
#else
    info->iface_ver = SIR_PLUGIN_VCURRENT;
#endif
    info->maj_ver   = maj_ver;
    info->min_ver   = min_ver;
    info->bld_ver   = bld_ver;
#if defined(PLUGINDUMMY_BADBEHAVIOR3)
    info->levels    = 0xfe23;
    info->opts      = 0x1234abcd;
    info->author    = NULL;
    SIR_UNUSED(author);
    info->desc      = "";
    SIR_UNUSED(desc);
#else
    info->levels    = levels;
    info->opts      = opts;
    info->author    = author;
    info->desc      = desc;
#endif
    info->caps      = caps;

    (void)printf("\t" SIR_DGRAY("" PLUGIN_NAME " ('%s')") SIR_EOL, __func__);

#if defined(PLUGINDUMMY_BADBEHAVIOR1)
    return false;
#else
    return true;
#endif
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movb $0x1, (%rax)
movq (%rsp), %rax
movb $0x1, 0x1(%rax)
movq (%rsp), %rax
movb $0x0, 0x2(%rax)
movq (%rsp), %rax
movb $0x0, 0x3(%rax)
movq (%rsp), %rax
movw $0xc0, 0x4(%rax)
movq (%rsp), %rax
movl $0x4400, 0x8(%rax)      # imm = 0x4400
movq 0x2ed8(%rip), %rcx      # 0x4028
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x2ed1(%rip), %rcx      # 0x4030
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
leaq 0xe86(%rip), %rdi       # 0x2000
leaq 0xea8(%rip), %rsi       # 0x2029
movb $0x0, %al
callq 0x1030
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/./plugins/dummy_bad4/../dummy/plugin_dummy.c
// Function: sir_plugin_write
PLUGIN_EXPORT bool sir_plugin_write(sir_level level, const char* message) {
#if defined(PLUGINDUMMY_BADBEHAVIOR6)
    SIR_UNUSED(level);
    SIR_UNUSED(message);
    return false;
#else
    (void)printf("\t" SIR_DGRAY("" PLUGIN_NAME " (%s): level: %04"PRIx16", message: %s"),
                 __func__, level, message);
    return true;
#endif
}

// Assembly:
subq $0x18, %rsp
movw %di, %ax
movw %ax, 0x16(%rsp)
movq %rsi, 0x8(%rsp)
movzwl 0x16(%rsp), %edx
movq 0x8(%rsp), %rcx
leaq 0xe88(%rip), %rdi       # 0x203a
leaq 0xec1(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1030
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/rng.c
// Function: randombytes
void randombytes(void *x, size_t l)
{
    static int fd = -1;
    ssize_t n;
    if (fd < 0 && 0 > (fd = open("/dev/urandom", O_RDONLY)))
        exit(1);
    for (size_t i = 0; i < l; i += n)
        if (0 >= (n = read(fd, (char *) x + i, l - i)))
            exit(2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x0, 0x5e93(%rip)      # 0x7078
jge 0x120f
leaq 0x3fea(%rip), %rdi      # 0x51d8
xorl %esi, %esi
movb $0x0, %al
callq 0x10b0
movl %eax, %ecx
movl %ecx, 0x5e79(%rip)      # 0x7078
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x120f
movl $0x1, %edi
callq 0x10c0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x126f
movl 0x5e4e(%rip), %edi      # 0x7078
movq 0x20(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq 0x8(%rsp), %rdx
callq 0x1070
movq %rax, %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq %rcx, %rax
jl 0x125c
movl $0x2, %edi
callq 0x10c0
jmp 0x125e
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1218
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/mont.c
// Function: xDBLADD
void xDBLADD(proj *R, proj *S, proj const *P, proj const *Q, proj const *PQ, proj const *A)
{
    fp a, b, c, d;

    fp_add3(&a, &Q->x, &Q->z);
    fp_sub3(&b, &Q->x, &Q->z);
    fp_add3(&c, &P->x, &P->z);
    fp_sub3(&d, &P->x, &P->z);
    fp_sq2(&R->x, &c);
    fp_sq2(&S->x, &d);
    fp_mul2(&c, &b);
    fp_mul2(&d, &a);
    fp_sub3(&b, &R->x, &S->x);
    fp_add3(&a, &A->z, &A->z); /* multiplication by 2 */
    fp_mul3(&R->z, &a, &S->x);
    fp_add3(&S->x, &A->x, &a);
    fp_add2(&R->z, &R->z); /* multiplication by 2 */
    fp_mul2(&R->x, &R->z);
    fp_mul2(&S->x, &b);
    fp_sub3(&S->z, &c, &d);
    fp_add2(&R->z, &S->x);
    fp_add3(&S->x, &c, &d);
    fp_mul2(&R->z, &b);
    fp_sq2(&d, &S->z);
    fp_sq2(&b, &S->x);
    fp_mul3(&S->x, &PQ->z, &b);
    fp_mul3(&S->z, &PQ->x, &d);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq %r8, 0x110(%rsp)
movq %r9, 0x108(%rsp)
movq 0x118(%rsp), %rsi
movq 0x118(%rsp), %rdx
addq $0x40, %rdx
leaq 0xc8(%rsp), %rdi
callq 0x15b7
movq 0x118(%rsp), %rsi
movq 0x118(%rsp), %rdx
addq $0x40, %rdx
leaq 0x88(%rsp), %rdi
callq 0x15cb
movq 0x120(%rsp), %rsi
movq 0x120(%rsp), %rdx
addq $0x40, %rdx
leaq 0x48(%rsp), %rdi
callq 0x15b7
movq 0x120(%rsp), %rsi
movq 0x120(%rsp), %rdx
addq $0x40, %rdx
leaq 0x8(%rsp), %rdi
callq 0x15cb
movq 0x130(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x224e
movq 0x128(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x224e
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x2246
leaq 0x8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x2246
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x15cb
movq 0x108(%rsp), %rsi
addq $0x40, %rsi
movq 0x108(%rsp), %rdx
addq $0x40, %rdx
leaq 0xc8(%rsp), %rdi
callq 0x15b7
movq 0x130(%rsp), %rdi
addq $0x40, %rdi
movq 0x128(%rsp), %rdx
leaq 0xc8(%rsp), %rsi
callq 0x166d
movq 0x128(%rsp), %rdi
movq 0x108(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
callq 0x15b7
movq 0x130(%rsp), %rdi
addq $0x40, %rdi
movq 0x130(%rsp), %rsi
addq $0x40, %rsi
callq 0x15c3
movq 0x130(%rsp), %rdi
movq 0x130(%rsp), %rsi
addq $0x40, %rsi
callq 0x2246
movq 0x128(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x2246
movq 0x128(%rsp), %rdi
addq $0x40, %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x15cb
movq 0x130(%rsp), %rdi
addq $0x40, %rdi
movq 0x128(%rsp), %rsi
callq 0x15c3
movq 0x128(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x15b7
movq 0x130(%rsp), %rdi
addq $0x40, %rdi
leaq 0x88(%rsp), %rsi
callq 0x2246
movq 0x128(%rsp), %rsi
addq $0x40, %rsi
leaq 0x8(%rsp), %rdi
callq 0x224e
movq 0x128(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x224e
movq 0x128(%rsp), %rdi
movq 0x110(%rsp), %rsi
addq $0x40, %rsi
leaq 0x88(%rsp), %rdx
callq 0x166d
movq 0x128(%rsp), %rdi
addq $0x40, %rdi
movq 0x110(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x166d
addq $0x138, %rsp            # imm = 0x138
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/mont.c
// Function: xDBL
void xDBL(proj *Q, proj const *A, proj const *P)
{
    fp a, b, c;
    fp_add3(&a, &P->x, &P->z);
    fp_sq1(&a);
    fp_sub3(&b, &P->x, &P->z);
    fp_sq1(&b);
    fp_sub3(&c, &a, &b);
    fp_add2(&b, &b); fp_add2(&b, &b); /* multiplication by 4 */
    fp_mul2(&b, &A->z);
    fp_mul3(&Q->x, &a, &b);
    fp_add3(&a, &A->z, &A->z); /* multiplication by 2 */
    fp_add2(&a, &A->x);
    fp_mul2(&a, &c);
    fp_add2(&a, &b);
    fp_mul3(&Q->z, &a, &c);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc0(%rsp), %rdx
addq $0x40, %rdx
leaq 0x80(%rsp), %rdi
callq 0x15b7
leaq 0x80(%rsp), %rdi
callq 0x2256
movq 0xc0(%rsp), %rsi
movq 0xc0(%rsp), %rdx
addq $0x40, %rdx
leaq 0x40(%rsp), %rdi
callq 0x15cb
leaq 0x40(%rsp), %rdi
callq 0x2256
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x15cb
leaq 0x40(%rsp), %rsi
movq %rsi, %rdi
callq 0x15c3
leaq 0x40(%rsp), %rsi
movq %rsi, %rdi
callq 0x15c3
movq 0xc8(%rsp), %rsi
addq $0x40, %rsi
leaq 0x40(%rsp), %rdi
callq 0x2246
movq 0xd0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x166d
movq 0xc8(%rsp), %rsi
addq $0x40, %rsi
movq 0xc8(%rsp), %rdx
addq $0x40, %rdx
leaq 0x80(%rsp), %rdi
callq 0x15b7
movq 0xc8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x15c3
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
callq 0x2246
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x15c3
movq 0xd0(%rsp), %rdi
addq $0x40, %rdi
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
callq 0x166d
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/mont.c
// Function: xADD
void xADD(proj *S, proj const *P, proj const *Q, proj const *PQ)
{
    fp a, b, c, d;
    fp_add3(&a, &P->x, &P->z);
    fp_sub3(&b, &P->x, &P->z);
    fp_add3(&c, &Q->x, &Q->z);
    fp_sub3(&d, &Q->x, &Q->z);
    fp_mul2(&a, &d);
    fp_mul2(&b, &c);
    fp_add3(&c, &a, &b);
    fp_sub3(&d, &a, &b);
    fp_sq1(&c);
    fp_sq1(&d);
    fp_mul3(&S->x, &PQ->z, &c);
    fp_mul3(&S->z, &PQ->x, &d);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
movq 0x118(%rsp), %rsi
movq 0x118(%rsp), %rdx
addq $0x40, %rdx
leaq 0xc8(%rsp), %rdi
callq 0x15b7
movq 0x118(%rsp), %rsi
movq 0x118(%rsp), %rdx
addq $0x40, %rdx
leaq 0x88(%rsp), %rdi
callq 0x15cb
movq 0x110(%rsp), %rsi
movq 0x110(%rsp), %rdx
addq $0x40, %rdx
leaq 0x48(%rsp), %rdi
callq 0x15b7
movq 0x110(%rsp), %rsi
movq 0x110(%rsp), %rdx
addq $0x40, %rdx
leaq 0x8(%rsp), %rdi
callq 0x15cb
leaq 0xc8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2246
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2246
leaq 0x48(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x15b7
leaq 0x8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x15cb
leaq 0x48(%rsp), %rdi
callq 0x2256
leaq 0x8(%rsp), %rdi
callq 0x2256
movq 0x120(%rsp), %rdi
movq 0x108(%rsp), %rsi
addq $0x40, %rsi
leaq 0x48(%rsp), %rdx
callq 0x166d
movq 0x120(%rsp), %rdi
addq $0x40, %rdi
movq 0x108(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x166d
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/mont.c
// Function: xMUL
void xMUL(proj *Q, proj const *A, proj const *P, ui const *k)
{
    proj R = *P;
    const proj Pcopy = *P; /* in case Q = P */

    Q->x = fp_1;
    Q->z = fp_0;

    unsigned long i = 64 * LIMBS;
    while (--i && !ui_bit(k, i));

    do {

        bool bit = ui_bit(k, i);

        if (bit) { proj T = *Q; *Q = R; R = T; } /* not constant-time */
        //fp_cswap(&Q->x, &R.x, bit);
        //fp_cswap(&Q->z, &R.z, bit);

        xDBLADD(Q, &R, Q, &R, &Pcopy, A);

        if (bit) { proj T = *Q; *Q = R; R = T; } /* not constant-time */
        //fp_cswap(&Q->x, &R.x, bit);
        //fp_cswap(&Q->z, &R.z, bit);

    } while (i--);
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq %rcx, 0x218(%rsp)
movq 0x220(%rsp), %rsi
leaq 0x198(%rsp), %rdi
movl $0x80, %edx
callq 0x1090
movq 0x220(%rsp), %rsi
leaq 0x118(%rsp), %rdi
movl $0x80, %edx
callq 0x1090
movq 0x230(%rsp), %rdi
leaq 0x2536(%rip), %rsi      # 0x5090
movl $0x40, %edx
callq 0x1090
movq 0x230(%rsp), %rdi
addq $0x40, %rdi
leaq 0x24d9(%rip), %rsi      # 0x5050
movl $0x40, %edx
callq 0x1090
movq $0x200, 0x110(%rsp) # imm = 0x200
movq 0x110(%rsp), %rcx
addq $-0x1, %rcx
movq %rcx, 0x110(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x7(%rsp)
je 0x2bc8
movq 0x218(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x1288
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2bd2
jmp 0x2bd4
jmp 0x2b8d
jmp 0x2bd6
movq 0x218(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x1288
andb $0x1, %al
movb %al, 0x10f(%rsp)
testb $0x1, 0x10f(%rsp)
je 0x2c4c
movq 0x230(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movl $0x80, %edx
callq 0x1090
movq 0x230(%rsp), %rdi
leaq 0x198(%rsp), %rsi
movl $0x80, %edx
callq 0x1090
leaq 0x198(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl $0x80, %edx
callq 0x1090
movq 0x230(%rsp), %rdi
movq 0x230(%rsp), %rdx
movq 0x228(%rsp), %r9
leaq 0x198(%rsp), %rcx
leaq 0x118(%rsp), %r8
movq %rcx, %rsi
callq 0x2590
testb $0x1, 0x10f(%rsp)
je 0x2cce
movq 0x230(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movl $0x80, %edx
callq 0x1090
movq 0x230(%rsp), %rdi
leaq 0x198(%rsp), %rsi
movl $0x80, %edx
callq 0x1090
leaq 0x198(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x80, %edx
callq 0x1090
jmp 0x2cd0
movq 0x110(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x110(%rsp)
cmpq $0x0, %rax
jne 0x2bd6
addq $0x238, %rsp            # imm = 0x238
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh.c
// Function: csidh_private
__attribute__((visibility("default"))) void csidh_private(private_key *priv)
{
    memset(&priv->e, 0, sizeof(priv->e));
    for (size_t i = 0; i < NUM_PRIMES; ) {
        int8_t buf[64];
        randombytes(buf, sizeof(buf));
        for (size_t j = 0; j < sizeof(buf); ++j) {
            if (buf[j] <= MAX_EXPONENT && buf[j] >= -MAX_EXPONENT) {
                priv->e[i / 2] |= (buf[j] & 0xf) << i % 2 * 4;
                if (++i >= NUM_PRIMES)
                    break;
            }
        }
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x25, %edx
callq 0x1060
movq $0x0, 0x58(%rsp)
cmpq $0x4a, 0x58(%rsp)
jae 0x35a3
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x11d0
movq $0x0, 0x8(%rsp)
cmpq $0x40, 0x8(%rsp)
jae 0x359e
movq 0x8(%rsp), %rax
movsbl 0x10(%rsp,%rax), %eax
cmpl $0x5, %eax
jg 0x3589
movq 0x8(%rsp), %rax
movsbl 0x10(%rsp,%rax), %eax
cmpl $-0x5, %eax
jl 0x3589
movq 0x8(%rsp), %rax
movsbl 0x10(%rsp,%rax), %esi
andl $0xf, %esi
movq 0x58(%rsp), %rax
andq $0x1, %rax
shlq $0x2, %rax
movl %eax, %ecx
shll %cl, %esi
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
shrq %rcx
movsbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
cmpq $0x4a, %rax
jb 0x3587
jmp 0x359e
jmp 0x3589
jmp 0x358b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3517
jmp 0x34f3
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh.c
// Function: validate
bool validate(public_key const *in)
{
    /* make sure the curve is nonsingular: A^2-4 != 0 */
    {
        ui dummy;
        if (!ui_sub3(&dummy, (ui *) &in->A, &p)) /* returns borrow */
            /* A >= p */
            return false;

        fp fp_pm2;
        fp_set(&fp_pm2, 2);
        if (!memcmp(&in->A, &fp_pm2, sizeof(fp)))
            /* A = 2 */
            return false;

        fp_sub3(&fp_pm2, &fp_0, &fp_pm2);
        if (!memcmp(&in->A, &fp_pm2, sizeof(fp)))
            /* A = -2 */
            return false;
    }

    const proj A = {in->A, fp_1};

    do {
        proj P;
        fp_random(&P.x);
        P.z = fp_1;

        /* maximal 2-power in p+1 */
        xDBL(&P, &A, &P);
        xDBL(&P, &A, &P);

        bool is_supersingular;
        ui order = ui_1;

        if (validate_rec(&P, &A, 0, NUM_PRIMES, &order, &is_supersingular))
            return is_supersingular;

    /* P didn't have big enough order to prove supersingularity. */
    } while (1);
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rsi
leaq 0x188(%rsp), %rdi
leaq 0x1a3a(%rip), %rdx      # 0x5010
callq 0x1304
testb $0x1, %al
jne 0x35ec
movb $0x0, 0x1d7(%rsp)
jmp 0x374c
leaq 0x148(%rsp), %rdi
movl $0x2, %esi
callq 0x13ec
movq 0x1c8(%rsp), %rdi
leaq 0x148(%rsp), %rsi
movl $0x40, %edx
callq 0x1080
cmpl $0x0, %eax
jne 0x362a
movb $0x0, 0x1d7(%rsp)
jmp 0x374c
leaq 0x148(%rsp), %rdx
leaq 0x1a17(%rip), %rsi      # 0x5050
movq %rdx, %rdi
callq 0x15cb
movq 0x1c8(%rsp), %rdi
leaq 0x148(%rsp), %rsi
movl $0x40, %edx
callq 0x1080
cmpl $0x0, %eax
jne 0x366d
movb $0x0, 0x1d7(%rsp)
jmp 0x374c
leaq 0xc8(%rsp), %rdi
movq 0x1c8(%rsp), %rsi
movl $0x40, %edx
callq 0x1090
leaq 0xc8(%rsp), %rdi
addq $0x40, %rdi
leaq 0x19f6(%rip), %rsi      # 0x5090
movl $0x40, %edx
callq 0x1090
leaq 0x48(%rsp), %rdi
callq 0x24c7
leaq 0x48(%rsp), %rdi
addq $0x40, %rdi
leaq 0x19d2(%rip), %rsi      # 0x5090
movl $0x40, %edx
callq 0x1090
leaq 0x48(%rsp), %rdx
leaq 0xc8(%rsp), %rsi
movq %rdx, %rdi
callq 0x2830
leaq 0x48(%rsp), %rdx
leaq 0xc8(%rsp), %rsi
movq %rdx, %rdi
callq 0x2830
movq %rsp, %rdi
leaq 0x1ae9(%rip), %rsi      # 0x51e5
movl $0x40, %edx
callq 0x1090
leaq 0x48(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x4a, %ecx
movq %rsp, %r8
leaq 0x47(%rsp), %r9
callq 0x3760
testb $0x1, %al
jne 0x372f
jmp 0x373e
movb 0x47(%rsp), %al
andb $0x1, %al
movb %al, 0x1d7(%rsp)
jmp 0x374c
jmp 0x3740
movb $0x1, %al
testb $0x1, %al
jne 0x36a4
jmp 0x374c
movb 0x1d7(%rsp), %al
andb $0x1, %al
addq $0x1d8, %rsp            # imm = 0x1D8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh.c
// Function: montgomery_rhs
static void montgomery_rhs(fp *rhs, fp const *A, fp const *x)
{
    fp tmp;
    *rhs = *x;
    fp_sq1(rhs);
    fp_mul3(&tmp, A, x);
    fp_add2(rhs, &tmp);
    fp_add2(rhs, &fp_1);
    fp_mul2(rhs, x);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x40, %edx
callq 0x1090
movq 0x50(%rsp), %rdi
callq 0x2256
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq %rsp, %rdi
callq 0x166d
movq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x15c3
movq 0x50(%rsp), %rdi
leaq 0xf04(%rip), %rsi       # 0x5090
callq 0x15c3
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2246
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh.c
// Function: csidh
__attribute__((visibility("default"))) bool csidh(public_key *out, public_key const *in, private_key const *priv)
{
    if (!validate(in)) {
        fp_random(&out->A);
        return false;
    }
    action(out, in, priv);
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x35b0
testb $0x1, %al
jne 0x41e2
movq 0x18(%rsp), %rdi
callq 0x24c7
movb $0x0, 0x27(%rsp)
jmp 0x41fb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3af0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c, unsigned long long *clen,         // Ciphertext out
    const unsigned char *m, unsigned long long mlen,    // Plaintext in
    const unsigned char *ad, unsigned long long adlen,  // AAD in
    const unsigned char *nsec,                          // Secret Nonce in
    const unsigned char *npub,                          // Public Nonce in
    const unsigned char *k)                             // Secret Key in
{
    sbob_t  cb;                         // Local state

    sbob_clr(&cb);                      // Clear state

#if (CRYPTO_KEYBYTES > 0)
    // Secret Key
    sbob_put(&cb, BLNK_KEY, k, CRYPTO_KEYBYTES);
    sbob_fin(&cb, BLNK_KEY);
#endif

#if (CRYPTO_NPUBBYTES > 0)
    // Mix the public seq. number
    sbob_put(&cb, BLNK_NPUB, npub, CRYPTO_NPUBBYTES);
    sbob_fin(&cb, BLNK_NPUB);
#endif

#if (CRYPTO_NSECBYTES > 0)
    // Secret Sequence Number, store at start of c
    sbob_enc(&cb, BLNK_NSEC, c, nsec, CRYPTO_NSECBYTES);
    sbob_fin(&cb, BLNK_NSEC);
    c += CRYPTO_NSEC_BYTES:
#endif

    // Associated Data
    sbob_put(&cb, BLNK_AAD, ad, (size_t) adlen);
    sbob_fin(&cb, BLNK_AAD);

    // Encrypt Message
    sbob_enc(&cb, BLNK_MSG, c, m, (size_t) mlen);
    sbob_fin(&cb, BLNK_MSG);
    c += mlen;

#if (SBOB_MACSIZE > 0)
    sbob_get(&cb, BLNK_MAC, c, SBOB_MACSIZE);
    //sbob_fin(&cb, BLNK_MAC);          // Required if MAC-and-Continue
#endif
    sbob_clr(&cb);                      // Clear sensitive data

    *clen = mlen + CRYPTO_ABYTES;       // store length

    return 0;                           // Success.
}

// Assembly:
subq $0x78, %rsp
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq %rsp, %rdi
callq 0x1050
movq 0x90(%rsp), %rdx
movq %rsp, %rdi
movl $0x10, %esi
movl $0x18, %ecx
callq 0x10d0
movq %rsp, %rdi
movl $0x10, %esi
callq 0x10b0
movq 0x88(%rsp), %rdx
movq %rsp, %rdi
movl $0x20, %esi
movl $0x10, %ecx
callq 0x10d0
movq %rsp, %rdi
movl $0x20, %esi
callq 0x10b0
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %rsp, %rdi
movl $0x40, %esi
callq 0x10d0
movq %rsp, %rdi
movl $0x40, %esi
callq 0x10b0
movq 0x70(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %r8
movq %rsp, %rdi
movl $0x50, %esi
callq 0x1070
movq %rsp, %rdi
movl $0x50, %esi
callq 0x10b0
movq 0x58(%rsp), %rax
addq 0x70(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdx
movq %rsp, %rdi
movl $0x60, %esi
movl $0x10, %ecx
callq 0x1030
movq %rsp, %rdi
callq 0x1050
movq 0x58(%rsp), %rcx
addq $0x10, %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/stribob.c
// Function: sbob_clr
void sbob_clr(sbob_t *sb)
{
    int i;

    for (i = 0; i < 8; i++)
        sb->s.q[i] = 0;
    sb->l = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x8, -0xc(%rsp)
jge 0x14b3
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x148d
movq -0x8(%rsp), %rax
movl $0x0, 0x40(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/stribob.c
// Function: sbob_fin
void sbob_fin(sbob_t *sb, sbob_pad_t pad)
{
    // pad
    sb->s.b[sb->l] ^= BLNK_END;
    sb->s.b[SBOB_RATE] ^= pad | BLNK_FIN;

    // compress and zero the buffer
    SBOB_PI(&sb->s);
    sb->l = 0;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0x40(%rcx), %rcx
movzbl (%rax,%rcx), %edx
xorl $0x1, %edx
movb %dl, (%rax,%rcx)
movzbl 0xf(%rsp), %edx
orl $0x2, %edx
movq 0x10(%rsp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rax)
movq 0x10(%rsp), %rdi
callq 0x1080
movq 0x10(%rsp), %rax
movl $0x0, 0x40(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/stribob.c
// Function: sbob_put
void sbob_put(sbob_t *sb, sbob_pad_t pad, const void *in, size_t len)
{
    int j;
    size_t i;

    j = sb->l;
    for (i = 0; i < len; i++) {
        if (j == SBOB_RATE) {
            sb->s.b[SBOB_RATE] ^= pad;
            SBOB_PI(&sb->s);
            j = 0;
        }
        sb->s.b[j++] ^= ((const uint8_t *) in)[i];
    }
    sb->l = j;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x15c3
cmpl $0x20, 0x14(%rsp)
jne 0x1587
movzbl 0x2f(%rsp), %edx
movq 0x30(%rsp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rax)
movq 0x30(%rsp), %rdi
callq 0x1080
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %esi
movq 0x30(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x14(%rsp)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x154f
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x40(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)