LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcache1AllocPage
static PgHdr1 *pcache1AllocPage(PCache1 *pCache, int benignMalloc){
  PgHdr1 *p = 0;
  void *pPg;

  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){
    p = pCache->pFree;
    pCache->pFree = p->pNext;
    p->pNext = 0;
  }else{
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    /* The group mutex must be released before pcache1Alloc() is called. This
    ** is because it might call sqlite3_release_memory(), which assumes that 
    ** this mutex is not held. */
    assert( pcache1.separateCache==0 );
    assert( pCache->pGroup==&pcache1.grp );
    pcache1LeaveMutex(pCache->pGroup);
#endif
    if( benignMalloc ){ sqlite3BeginBenignMalloc(); }
#ifdef SQLITE_PCACHE_SEPARATE_HEADER
    pPg = pcache1Alloc(pCache->szPage);
    p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra);
    if( !pPg || !p ){
      pcache1Free(pPg);
      sqlite3_free(p);
      pPg = 0;
    }
#else
    pPg = pcache1Alloc(pCache->szAlloc);
    p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
#endif
    if( benignMalloc ){ sqlite3EndBenignMalloc(); }
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    pcache1EnterMutex(pCache->pGroup);
#endif
    if( pPg==0 ) return 0;
    p->page.pBuf = pPg;
    p->page.pExtra = &p[1];
    p->isBulkLocal = 0;
    p->isAnchor = 0;
  }
  if( pCache->bPurgeable ){
    pCache->pGroup->nCurrentPage++;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x9f26a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x9f294
movq -0x10(%rbp), %rdi
callq 0x9f340
cmpl $0x0, %eax
je 0x9f294
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x9f309
cmpl $0x0, -0x14(%rbp)
je 0x9f29f
callq 0x2a3f0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x2c040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9f2cd
callq 0x2a440
cmpq $0x0, -0x28(%rbp)
jne 0x9f2de
movq $0x0, -0x8(%rbp)
jmp 0x9f32b
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x38, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x16(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x9f323
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcache1InitBulk
static int pcache1InitBulk(PCache1 *pCache){
  i64 szBulk;
  char *zBulk;
  if( pcache1.nInitPage==0 ) return 0;
  /* Do not bother with a bulk allocation if the cache size very small */
  if( pCache->nMax<3 ) return 0;
  sqlite3BeginBenignMalloc();
  if( pcache1.nInitPage>0 ){
    szBulk = pCache->szAlloc * (i64)pcache1.nInitPage;
  }else{
    szBulk = -1024 * (i64)pcache1.nInitPage;
  }
  if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){
    szBulk = pCache->szAlloc*pCache->nMax;
  }
  zBulk = pCache->pBulk = sqlite3Malloc( szBulk );
  sqlite3EndBenignMalloc();
  if( zBulk ){
    int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc;
    int i;
    for(i=0; i<nBulk; i++){
      PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage];
      pX->page.pBuf = zBulk;
      pX->page.pExtra = &pX[1];
      pX->isBulkLocal = 1;
      pX->isAnchor = 0;
      pX->pNext = pCache->pFree;
      pCache->pFree = pX;
      zBulk += pCache->szAlloc;
    }
  }
  return pCache->pFree!=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x22385(%rip)     # 0xc16d8
jne 0x9f361
movl $0x0, -0x4(%rbp)
jmp 0x9f4bc
movq -0x10(%rbp), %rax
cmpl $0x3, 0x1c(%rax)
jae 0x9f377
movl $0x0, -0x4(%rbp)
jmp 0x9f4bc
callq 0x2a3f0
cmpl $0x0, 0x22355(%rip)     # 0xc16d8
jle 0x9f39e
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rax
movslq 0x22344(%rip), %rcx     # 0xc16d8
imulq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x9f3b0
movslq 0x22333(%rip), %rax     # 0xc16d8
imulq $-0x400, %rax, %rax     # imm = 0xFC00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x1c(%rdx), %edx
imulq %rdx, %rcx
cmpq %rcx, %rax
jle 0x9f3e1
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x1c(%rcx), %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdba0
movq -0x10(%rbp), %rcx
movq %rax, 0x48(%rcx)
movq %rax, -0x20(%rbp)
callq 0x2a440
cmpq $0x0, -0x20(%rbp)
je 0x9f4a8
movq -0x20(%rbp), %rdi
callq 0xdd10
movq -0x10(%rbp), %rcx
cltd
idivl 0x10(%rcx)
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x9f4a6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
addq $0x38, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x16(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x9f421
jmp 0x9f4a8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerCheckpoint
SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
  int rc = SQLITE_OK;
  if( pPager->pWal ){
    rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
        (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
        pPager->pBusyHandlerArg,
        pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
        pnLog, pnCkpt
    );
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x118(%rax)
je 0x9fae5
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x9fa83
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x9fa92
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rcx
movq -0x8(%rbp), %rax
movzbl 0xd(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %r9d
movq -0x8(%rbp), %rax
movq 0x108(%rax), %r11
movq -0x18(%rbp), %r10
movq -0x20(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x2c6a0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: binCollFunc
static int binCollFunc(
  void *padFlag,
  int nKey1, const void *pKey1,
  int nKey2, const void *pKey2
){
  int rc, n;
  n = nKey1<nKey2 ? nKey1 : nKey2;
  /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
  ** strings byte by byte using the memcmp() function from the standard C
  ** library. */
  rc = memcmp(pKey1, pKey2, n);
  if( rc==0 ){
    if( padFlag
     && allSpaces(((char*)pKey1)+n, nKey1-n)
     && allSpaces(((char*)pKey2)+n, nKey2-n)
    ){
      /* EVIDENCE-OF: R-31624-24737 RTRIM is like BINARY except that extra
      ** spaces at the end of either string do not change the result. In other
      ** words, strings will compare equal to one another as long as they
      ** differ only in the number of spaces at the end.
      */
    }else{
      rc = nKey1 - nKey2;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x9fb1a
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x9fb20
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0xb350
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x9fb8a
cmpq $0x0, -0x8(%rbp)
je 0x9fb7f
movq -0x18(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
subl -0x30(%rbp), %esi
callq 0x9fd40
cmpl $0x0, %eax
je 0x9fb7f
movq -0x28(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
subl -0x30(%rbp), %esi
callq 0x9fd40
cmpl $0x0, %eax
je 0x9fb7f
jmp 0x9fb88
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9fb8a
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: cffi_init
static PyObject *_cffi_init(const char *module_name, Py_ssize_t version,
                            const struct _cffi_type_context_s *ctx)
{
    PyObject *module, *o_arg, *new_module;
    void *raw[] = {
        (void *)module_name,
        (void *)version,
        (void *)_cffi_exports,
        (void *)ctx,
    };

    module = PyImport_ImportModule("_cffi_backend");
    if (module == NULL)
        goto failure;

    o_arg = PyLong_FromVoidPtr((void *)raw);
    if (o_arg == NULL)
        goto failure;

    new_module = PyObject_CallMethod(
        module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg);

    Py_DECREF(o_arg);
    Py_DECREF(module);
    return new_module;

  failure:
    Py_XDECREF(module);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x17078(%rip), %rax     # 0x1b310
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xdd5b(%rip), %rdi      # 0x12006
callq 0x4130
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x42bd
jmp 0x4310
leaq -0x30(%rbp), %rdi
callq 0x40e0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x42d3
jmp 0x4310
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rcx
leaq 0xdd32(%rip), %rsi      # 0x12014
leaq 0xdd4a(%rip), %rdx      # 0x12033
movb $0x0, %al
callq 0x4040
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4350
movq -0x58(%rbp), %rdi
callq 0x4350
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4321
movq -0x58(%rbp), %rdi
callq 0x4390
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4345
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: cffi_f_do_op
static PyObject *
_cffi_f_do_op(PyObject *self, PyObject *arg0)
{
  struct em8051 * x0;
  Py_ssize_t datasize;
  struct _cffi_freeme_s *large_args_free = NULL;
  int result;
  PyObject *pyresult;

  datasize = _cffi_prepare_pointer_call_argument(
      _cffi_type(1), arg0, (char **)&x0);
  if (datasize != 0) {
    x0 = ((size_t)datasize) <= 640 ? (struct em8051 *)alloca((size_t)datasize) : NULL;
    if (_cffi_convert_array_argument(_cffi_type(1), arg0, (char **)&x0,
            datasize, &large_args_free) < 0)
      return NULL;
  }

  Py_BEGIN_ALLOW_THREADS
  _cffi_restore_errno();
  { result = do_op(x0); }
  _cffi_save_errno();
  Py_END_ALLOW_THREADS

  (void)self; /* unused */
  pyresult = _cffi_from_c_int(result, int);
  if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free);
  return pyresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x159cc(%rip), %rax     # 0x1b3c8
movq 0x156d5(%rip), %rdi     # 0x1b0d8
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5a7a
cmpq $0x280, -0x38(%rbp)     # imm = 0x280
ja 0x5a3d
movq -0x38(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x58(%rbp)
jmp 0x5a45
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x5a45
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x15684(%rip), %rdi     # 0x1b0d8
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %r8
callq 0x6470
cmpl $0x0, %eax
jge 0x5a78
movq $0x0, -0x20(%rbp)
jmp 0x5ac9
jmp 0x5a7a
callq 0x4150
movq %rax, -0x50(%rbp)
callq *0x158ef(%rip)          # 0x1b378
movq -0x10(%rbp), %rdi
callq 0x10ca0
movl %eax, -0x3c(%rbp)
callq *0x158e5(%rip)          # 0x1b380
movq -0x50(%rbp), %rdi
callq 0x4050
movslq -0x3c(%rbp), %rdi
callq 0x40d0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5ac1
movq -0x18(%rbp), %rdi
callq 0x6530
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5aec
movq -0x60(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
callq 0x4080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: em8051exception_callback
static void em8051exception_callback(struct em8051 * a0, int a1)
{
  char a[16];
  char *p = a;
  *(struct em8051 * *)(p + 0) = a0;
  *(int *)(p + 8) = a1;
  _cffi_call_python(&_cffi_externpy__em8051exception_callback, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x15878(%rip), %rax     # 0x1b3d8
movq -0x38(%rbp), %rsi
leaq 0x156f5(%rip), %rdi     # 0x1b260
callq *%rax
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5b85
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: em8051sfrread_callback
static int em8051sfrread_callback(struct em8051 * a0, int a1)
{
  char a[16];
  char *p = a;
  *(struct em8051 * *)(p + 0) = a0;
  *(int *)(p + 8) = a1;
  _cffi_call_python(&_cffi_externpy__em8051sfrread_callback, p);
  return *(int *)p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x15808(%rip), %rax     # 0x1b3d8
movq -0x38(%rbp), %rsi
leaq 0x156a5(%rip), %rdi     # 0x1b280
callq *%rax
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5c01
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: em8051sfrwrite_callback
static void em8051sfrwrite_callback(struct em8051 * a0, int a1)
{
  char a[16];
  char *p = a;
  *(struct em8051 * *)(p + 0) = a0;
  *(int *)(p + 8) = a1;
  _cffi_call_python(&_cffi_externpy__em8051sfrwrite_callback, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x15788(%rip), %rax     # 0x1b3d8
movq -0x38(%rbp), %rsi
leaq 0x15645(%rip), %rdi     # 0x1b2a0
callq *%rax
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5c75
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: em8051xread_callback
static int em8051xread_callback(struct em8051 * a0, int a1)
{
  char a[16];
  char *p = a;
  *(struct em8051 * *)(p + 0) = a0;
  *(int *)(p + 8) = a1;
  _cffi_call_python(&_cffi_externpy__em8051xread_callback, p);
  return *(int *)p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x15718(%rip), %rax     # 0x1b3d8
movq -0x38(%rbp), %rsi
leaq 0x155f5(%rip), %rdi     # 0x1b2c0
callq *%rax
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5cf1
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: em8051xwrite_callback
static void em8051xwrite_callback(struct em8051 * a0, int a1, int a2)
{
  char a[24];
  char *p = a;
  *(struct em8051 * *)(p + 0) = a0;
  *(int *)(p + 8) = a1;
  *(int *)(p + 16) = a2;
  _cffi_call_python(&_cffi_externpy__em8051xwrite_callback, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x30(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x1568b(%rip), %rax     # 0x1b3d8
movq -0x38(%rbp), %rsi
leaq 0x15588(%rip), %rdi     # 0x1b2e0
callq *%rax
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5d72
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: cffi_f_push_to_stack
static PyObject *
_cffi_f_push_to_stack(PyObject *self, PyObject *args)
{
  struct em8051 * x0;
  int x1;
  Py_ssize_t datasize;
  struct _cffi_freeme_s *large_args_free = NULL;
  PyObject *arg0;
  PyObject *arg1;

  if (!PyArg_UnpackTuple(args, "push_to_stack", 2, 2, &arg0, &arg1))
    return NULL;

  datasize = _cffi_prepare_pointer_call_argument(
      _cffi_type(1), arg0, (char **)&x0);
  if (datasize != 0) {
    x0 = ((size_t)datasize) <= 640 ? (struct em8051 *)alloca((size_t)datasize) : NULL;
    if (_cffi_convert_array_argument(_cffi_type(1), arg0, (char **)&x0,
            datasize, &large_args_free) < 0)
      return NULL;
  }

  x1 = _cffi_to_c_int(arg1, int);
  if (x1 == (int)-1 && PyErr_Occurred())
    return NULL;

  Py_BEGIN_ALLOW_THREADS
  _cffi_restore_errno();
  { push_to_stack(x0, x1); }
  _cffi_save_errno();
  Py_END_ALLOW_THREADS

  (void)self; /* unused */
  if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free);
  Py_INCREF(Py_None);
  return Py_None;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
leaq 0xc79f(%rip), %rsi      # 0x1276f
movl $0x2, %ecx
leaq -0x20(%rbp), %r8
leaq -0x28(%rbp), %r9
movq %rcx, %rdx
movb $0x0, %al
callq 0x4110
cmpl $0x0, %eax
jne 0x5ff9
movq $0x0, -0x30(%rbp)
jmp 0x60fa
movq 0x153c8(%rip), %rax     # 0x1b3c8
movq 0x150d1(%rip), %rdi     # 0x1b0d8
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq *%rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x607e
cmpq $0x280, -0x50(%rbp)     # imm = 0x280
ja 0x6041
movq -0x50(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x60(%rbp)
jmp 0x6049
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x6049
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x15080(%rip), %rdi     # 0x1b0d8
movq -0x20(%rbp), %rsi
movq -0x50(%rbp), %rcx
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %r8
callq 0x6470
cmpl $0x0, %eax
jge 0x607c
movq $0x0, -0x30(%rbp)
jmp 0x60fa
jmp 0x607e
movq 0x152b3(%rip), %rax     # 0x1b338
movq -0x28(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x60a9
callq 0x4120
cmpq $0x0, %rax
je 0x60a9
movq $0x0, -0x30(%rbp)
jmp 0x60fa
callq 0x4150
movq %rax, -0x58(%rbp)
callq *0x152c0(%rip)          # 0x1b378
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0xaef0
callq *0x152b6(%rip)          # 0x1b380
movq -0x58(%rbp), %rdi
callq 0x4050
cmpq $0x0, -0x18(%rbp)
je 0x60e3
movq -0x18(%rbp), %rdi
callq 0x6530
movq 0x14ef6(%rip), %rdi     # 0x1afe0
callq 0x6570
movq 0x14eea(%rip), %rax     # 0x1afe0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x611d
movq -0x68(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
callq 0x4080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: cffi_f_tick
static PyObject *
_cffi_f_tick(PyObject *self, PyObject *arg0)
{
  struct em8051 * x0;
  Py_ssize_t datasize;
  struct _cffi_freeme_s *large_args_free = NULL;
  int result;
  PyObject *pyresult;

  datasize = _cffi_prepare_pointer_call_argument(
      _cffi_type(1), arg0, (char **)&x0);
  if (datasize != 0) {
    x0 = ((size_t)datasize) <= 640 ? (struct em8051 *)alloca((size_t)datasize) : NULL;
    if (_cffi_convert_array_argument(_cffi_type(1), arg0, (char **)&x0,
            datasize, &large_args_free) < 0)
      return NULL;
  }

  Py_BEGIN_ALLOW_THREADS
  _cffi_restore_errno();
  { result = tick(x0); }
  _cffi_save_errno();
  Py_END_ALLOW_THREADS

  (void)self; /* unused */
  pyresult = _cffi_from_c_int(result, int);
  if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free);
  return pyresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x1507c(%rip), %rax     # 0x1b3c8
movq 0x14d85(%rip), %rdi     # 0x1b0d8
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x63ca
cmpq $0x280, -0x38(%rbp)     # imm = 0x280
ja 0x638d
movq -0x38(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x58(%rbp)
jmp 0x6395
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x6395
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x14d34(%rip), %rdi     # 0x1b0d8
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %r8
callq 0x6470
cmpl $0x0, %eax
jge 0x63c8
movq $0x0, -0x20(%rbp)
jmp 0x6419
jmp 0x63ca
callq 0x4150
movq %rax, -0x50(%rbp)
callq *0x14f9f(%rip)          # 0x1b378
movq -0x10(%rbp), %rdi
callq 0x6920
movl %eax, -0x3c(%rbp)
callq *0x14f95(%rip)          # 0x1b380
movq -0x50(%rbp), %rdi
callq 0x4050
movslq -0x3c(%rbp), %rdi
callq 0x40d0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6411
movq -0x18(%rbp), %rdi
callq 0x6530
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x643c
movq -0x60(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
callq 0x4080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: cffi_convert_array_argument
_CFFI_UNUSED_FN static int
_cffi_convert_array_argument(struct _cffi_ctypedescr *ctptr, PyObject *arg,
                             char **output_data, Py_ssize_t datasize,
                             struct _cffi_freeme_s **freeme)
{
    char *p;
    if (datasize < 0)
        return -1;

    p = *output_data;
    if (p == NULL) {
        struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc(
            offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize);
        if (fp == NULL)
            return -1;
        fp->next = *freeme;
        *freeme = fp;
        p = *output_data = (char *)&fp->alignment;
    }
    memset((void *)p, 0, (size_t)datasize);
    return _cffi_convert_array_from_object(p, ctptr, arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x649f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6525
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x64fe
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x4090
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x64d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6525
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x10, %rax
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x40a0
movq 0x14ebc(%rip), %rax     # 0x1b3d0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/ch55x.c
// Function: cffi_free_array_arguments
_CFFI_UNUSED_FN static void
_cffi_free_array_arguments(struct _cffi_freeme_s *freeme)
{
    do {
        void *p = (void *)freeme;
        freeme = freeme->next;
        PyObject_Free(p);
    } while (freeme != NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40c0
cmpq $0x0, -0x8(%rbp)
jne 0x653c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/core.c
// Function: tick
int tick(struct em8051 *aCPU)
{
    int v;
    int ticked = 0;

    if (aCPU->mTickDelay)
    {
        aCPU->mTickDelay--;
    }

    // Interrupts are sent if the following cases are not true:
    // 1. interrupt of equal or higher priority is in progress (tested inside function)
    // 2. current cycle is not the final cycle of instruction (tickdelay = 0)
    // 3. the instruction in progress is RETI or any write to the IE or IP regs (TODO)
    if (aCPU->mTickDelay == 0)
    {
        handle_interrupts(aCPU);
    }

    if (aCPU->mTickDelay == 0)
    {
        aCPU->mTickDelay = aCPU->op[aCPU->mCodeMem[aCPU->mPC & (aCPU->mCodeMemSize - 1)]](aCPU);
        ticked = 1;
        // update parity bit
        v = aCPU->mSFR[REG_ACC];
        v ^= v >> 4;
        v &= 0xf;
        v = (0x6996 >> v) & 1;
        aCPU->mSFR[REG_PSW] = (aCPU->mSFR[REG_PSW] & ~PSWMASK_P) | (v * PSWMASK_P);
    }

    timer_tick(aCPU);

    return ticked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x694a
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0x695d
movq -0x8(%rbp), %rdi
callq 0x6590
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0x6a03
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x38(%rdx), %edx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movq 0x40(%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x60(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
sarl $0x4, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movl $0x6996, %eax           # imm = 0x6996
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x50(%rax), %eax
andl $-0x2, %eax
movl -0xc(%rbp), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb %cl, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0x6a20
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/core.c
// Function: reset
void reset(struct em8051 *aCPU, int aWipe)
{
    // clear memory, set registers to bootup values, etc    
    if (aWipe)
    {
        memset(aCPU->mCodeMem, 0, aCPU->mCodeMemSize);
        memset(aCPU->mExtData, 0, aCPU->mExtDataSize);
        memset(aCPU->mLowerData, 0, 128);
        if (aCPU->mUpperData) 
            memset(aCPU->mUpperData, 0, 128);
    }

    memset(aCPU->mSFR, 0, 128);

    aCPU->mPC = 0;
    aCPU->mTickDelay = 0;
    aCPU->mSFR[REG_SP] = 7;
    aCPU->mSFR[REG_P0] = 0xff;
    aCPU->mSFR[REG_P1] = 0xff;
    aCPU->mSFR[REG_P2] = 0xff;
    aCPU->mSFR[REG_P3] = 0xff;

    // build function pointer lists

    disasm_setptrs(aCPU);
    op_setptrs(aCPU);

    // Clean internal variables
    aCPU->mInterruptActive = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x70c7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rdx
xorl %esi, %esi
callq 0x40a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rdx
xorl %esi, %esi
callq 0x40a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x40a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x70c5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x40a0
jmp 0x70c7
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x40a0
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $0x7, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $-0x1, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $-0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $-0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb $-0x1, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x78b0
movq -0x8(%rbp), %rdi
callq 0xafd0
movq -0x8(%rbp), %rax
movl $0x0, 0x1068(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/core.c
// Function: readbyte
int readbyte(FILE * f)
{
    char data[3];
    data[0] = fgetc(f);
    data[1] = fgetc(f);
    data[2] = 0;
    return strtol(data, NULL, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40b0
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40b0
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0xb(%rbp), %rdi
movl $0x10, %edx
callq 0x4100
movl %eax, -0x1c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x71c5
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_mov_rx_imm
static int disasm_mov_rx_imm(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    sprintf(aBuffer,"MOV   R%d, #%02Xh",
        aCPU->mCodeMem[aPosition&(aCPU->mCodeMemSize-1)]&7,
        aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)]);
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
andl $0x7, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
leaq 0xaea1(%rip), %rsi      # 0x134ef
movb $0x0, %al
callq 0x4160
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_mov_mem_rx
static int disasm_mov_mem_rx(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char mem[16];mem_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], mem);
    sprintf(aBuffer,"MOV   %s, R%d",
        mem,
        aCPU->mCodeMem[aPosition&(aCPU->mCodeMemSize-1)]&7);
    
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x73c0
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %ecx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
andl $0x7, %ecx
leaq 0xae30(%rip), %rsi      # 0x13501
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x86f5
movl $0x2, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_mov_rx_mem
static int disasm_mov_rx_mem(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char mem[16];mem_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], mem);
    sprintf(aBuffer,"MOV   R%d, %s",
        aCPU->mCodeMem[aPosition&(aCPU->mCodeMemSize-1)]&7,
        mem);
    
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x73c0
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %edx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %edx
andl $0x7, %edx
leaq 0xad5b(%rip), %rsi      # 0x1351c
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x87e5
movl $0x2, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_cjne_rx_imm_offset
static int disasm_cjne_rx_imm_offset(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    sprintf(aBuffer,"CJNE  R%d, #%02Xh, #%+d",
        aCPU->mCodeMem[aPosition&(aCPU->mCodeMemSize-1)]&7,
        aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)],
        (signed char)aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
andl $0x7, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x8(%rbp), %r8
movl 0x8(%r8), %r8d
subl $0x1, %r8d
andl %r8d, %esi
movslq %esi, %rsi
movsbl (%rax,%rsi), %r8d
leaq 0xacb8(%rip), %rsi      # 0x1352a
movb $0x0, %al
callq 0x4160
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_djnz_rx_offset
static int disasm_djnz_rx_offset(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    sprintf(aBuffer,"DJNZ  R%d, #%+d",
        aCPU->mCodeMem[aPosition&(aCPU->mCodeMemSize-1)]&7,
        (signed char)aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)]);
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
andl $0x7, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
leaq 0xac11(%rip), %rsi      # 0x1354f
movb $0x0, %al
callq 0x4160
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_nop
static int disasm_nop(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    if (aCPU->mCodeMem[aPosition&(aCPU->mCodeMemSize-1)])
        sprintf(aBuffer,"??UNKNOWN");
    else
        sprintf(aBuffer,"NOP");
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x8a36
movq -0x18(%rbp), %rdi
leaq 0xab4c(%rip), %rsi      # 0x13579
movb $0x0, %al
callq 0x4160
jmp 0x8a48
movq -0x18(%rbp), %rdi
leaq 0xab42(%rip), %rsi      # 0x13583
movb $0x0, %al
callq 0x4160
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_ajmp_offset
static int disasm_ajmp_offset(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    sprintf(aBuffer,"AJMP  #%04Xh",
        ((aPosition + 2) & 0xf800) |
        aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)] | 
        ((aCPU->mCodeMem[(aPosition)&(aCPU->mCodeMemSize-1)] & 0xe0) << 3));
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
andl $0xf800, %edx           # imm = 0xF800
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0xe0, %eax
shll $0x3, %eax
orl %eax, %edx
leaq 0xaab4(%rip), %rsi      # 0x13587
movb $0x0, %al
callq 0x4160
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_ljmp_address
static int disasm_ljmp_address(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    sprintf(aBuffer,"LJMP  #%04Xh",        
        (aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)] << 8) | 
        aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
shll $0x8, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
orl %eax, %edx
leaq 0xaa41(%rip), %rsi      # 0x13594
movb $0x0, %al
callq 0x4160
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_jbc_bitaddr_offset
static int disasm_jbc_bitaddr_offset(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char baddr[16];
    bitaddr_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], baddr);
    sprintf(aBuffer,"JBC   %s, #%+d",        
        baddr,
        (signed char)aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x7650
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
leaq 0xa8b4(%rip), %rsi      # 0x135c5
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8d35
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_lcall_address
static int disasm_lcall_address(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    sprintf(aBuffer,"LCALL #%04Xh",        
        (aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)] << 8) | 
        aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
shll $0x8, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %esi
subl $0x1, %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
orl %eax, %edx
leaq 0xa7ad(%rip), %rsi      # 0x135e0
movb $0x0, %al
callq 0x4160
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_jb_bitaddr_offset
static int disasm_jb_bitaddr_offset(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char baddr[16];
    bitaddr_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], baddr);
    sprintf(aBuffer,"JB   %s, #%+d",        
        baddr,
        (signed char)aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x7650
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
leaq 0xa620(%rip), %rsi      # 0x13611
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9015
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_jnb_bitaddr_offset
static int disasm_jnb_bitaddr_offset(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char baddr[16];
    bitaddr_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], baddr);
    sprintf(aBuffer,"JNB   %s, #%+d",        
        baddr,
        (signed char)aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x7650
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
leaq 0xa444(%rip), %rsi      # 0x13655
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9235
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_orl_mem_imm
static int disasm_orl_mem_imm(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char mem[16];mem_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], mem);
    sprintf(aBuffer,"ORL   %s, #%02Xh",        
        mem,
        aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x73c0
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
leaq 0xa1b1(%rip), %rsi      # 0x136b2
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9525
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliuswwj[P]emch55x/disasm.c
// Function: disasm_anl_mem_imm
static int disasm_anl_mem_imm(struct em8051 *aCPU, int aPosition, char *aBuffer)
{
    char mem[16];mem_memonic(aCPU->mCodeMem[(aPosition + 1)&(aCPU->mCodeMemSize-1)], mem);
    sprintf(aBuffer,"ANL   %s, #%02Xh",        
        mem,
        aCPU->mCodeMem[(aPosition + 2)&(aCPU->mCodeMemSize-1)]);
    
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq (%rdx), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
movl 0x8(%rdx), %edx
decl %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0x73c0
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movl 0x8(%rsi), %esi
decl %esi
andl %esi, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
leaq 0x9f73(%rip), %rsi      # 0x13704
xorl %eax, %eax
callq 0x4160
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x97b5
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x4080
nopw (%rax,%rax)