// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreeInitPage
static int btreeInitPage(MemPage *pPage){
  int pc;            /* Address of a freeblock within pPage->aData[] */
  u8 hdr;            /* Offset to beginning of page header */
  u8 *data;          /* Equal to pPage->aData */
  BtShared *pBt;        /* The main btree structure */
  int usableSize;    /* Amount of usable space on each page */
  u16 cellOffset;    /* Offset from start of page to first cell pointer */
  int nFree;         /* Number of unused bytes on the page */
  int top;           /* First byte of the cell content area */
  int iCellFirst;    /* First allowable cell or freeblock offset */
  int iCellLast;     /* Last possible cell or freeblock offset */

  assert( pPage->pBt!=0 );
  assert( pPage->pBt->db!=0 );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
  assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
  assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
  assert( pPage->isInit==0 );

  pBt = pPage->pBt;
  hdr = pPage->hdrOffset;
  data = pPage->aData;
  /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
  ** the b-tree page type. */
  if( decodeFlags(pPage, data[hdr]) ){
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
  pPage->maskPage = (u16)(pBt->pageSize - 1);
  pPage->nOverflow = 0;
  usableSize = pBt->usableSize;
  pPage->cellOffset = cellOffset = hdr + 8 + pPage->childPtrSize;
  pPage->aDataEnd = &data[usableSize];
  pPage->aCellIdx = &data[cellOffset];
  pPage->aDataOfst = &data[pPage->childPtrSize];
  /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates
  ** the start of the cell content area. A zero value for this integer is
  ** interpreted as 65536. */
  top = get2byteNotZero(&data[hdr+5]);
  /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
  ** number of cells on the page. */
  pPage->nCell = get2byte(&data[hdr+3]);
  if( pPage->nCell>MX_CELL(pBt) ){
    /* To many cells for a single page.  The page must be corrupt */
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  testcase( pPage->nCell==MX_CELL(pBt) );
  /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only
  ** possible for a root page of a table that contains no rows) then the
  ** offset to the cell content area will equal the page size minus the
  ** bytes of reserved space. */
  assert( pPage->nCell>0 || top==usableSize || CORRUPT_DB );

  /* A malformed database page might cause us to read past the end
  ** of page when parsing a cell.  
  **
  ** The following block of code checks early to see if a cell extends
  ** past the end of a page boundary and causes SQLITE_CORRUPT to be 
  ** returned if it does.
  */
  iCellFirst = cellOffset + 2*pPage->nCell;
  iCellLast = usableSize - 4;
  if( pBt->db->flags & SQLITE_CellSizeCk ){
    int i;            /* Index into the cell pointer array */
    int sz;           /* Size of a cell */

    if( !pPage->leaf ) iCellLast--;
    for(i=0; i<pPage->nCell; i++){
      pc = get2byteAligned(&data[cellOffset+i*2]);
      testcase( pc==iCellFirst );
      testcase( pc==iCellLast );
      if( pc<iCellFirst || pc>iCellLast ){
        return SQLITE_CORRUPT_PAGE(pPage);
      }
      sz = pPage->xCellSize(pPage, &data[pc]);
      testcase( pc+sz==usableSize );
      if( pc+sz>usableSize ){
        return SQLITE_CORRUPT_PAGE(pPage);
      }
    }
    if( !pPage->leaf ) iCellLast++;
  }  

  /* Compute the total free space on the page
  ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the
  ** start of the first freeblock on the page, or is zero if there are no
  ** freeblocks. */
  pc = get2byte(&data[hdr+1]);
  nFree = data[hdr+7] + top;  /* Init nFree to non-freeblock free space */
  if( pc>0 ){
    u32 next, size;
    if( pc<iCellFirst ){
      /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will
      ** always be at least one cell before the first freeblock.
      */
      return SQLITE_CORRUPT_PAGE(pPage); 
    }
    while( 1 ){
      if( pc>iCellLast ){
        /* Freeblock off the end of the page */
        return SQLITE_CORRUPT_PAGE(pPage);
      }
      next = get2byte(&data[pc]);
      size = get2byte(&data[pc+2]);
      nFree = nFree + size;
      if( next<=pc+size+3 ) break;
      pc = next;
    }
    if( next>0 ){
      /* Freeblock not in ascending order */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    if( pc+size>(unsigned int)usableSize ){
      /* Last freeblock extends past page end */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
  }

  /* At this point, nFree contains the sum of the offset to the start
  ** of the cell-content area plus the number of free bytes within
  ** the cell-content area. If this is greater than the usable-size
  ** of the page, then the page must be corrupted. This check also
  ** serves to verify that the offset to the start of the cell-content
  ** area, according to the page header, lies within the page.
  */
  if( nFree>usableSize ){
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  pPage->nFree = (u16)(nFree - iCellFirst);
  pPage->isInit = 1;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rbp
movq 0x50(%rdi), %r14
movzbl 0x9(%rdi), %r15d
movzbl (%r14,%r15), %esi
callq 0x41ec55
testl %eax, %eax
je 0x41e95c
leaq 0x131ff5(%rip), %rsi    # 0x55092f
leaq 0x132111(%rip), %rdx    # 0x550a52
leaq 0x131e1e(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc03, %ecx           # imm = 0xFC03
jmp 0x41e9f4
movl 0x30(%rbp), %ecx
leal -0x1(%rcx), %eax
movw %ax, 0x18(%rbx)
movb $0x0, 0xc(%rbx)
movslq 0x34(%rbp), %r13
movzbl 0xa(%rbx), %edx
leal (%r15,%rdx), %eax
leal 0x8(%r15,%rdx), %esi
movw %si, 0x12(%rbx)
leaq (%r14,%r13), %rsi
movq %rsi, 0x58(%rbx)
leaq (%r14,%rax), %rsi
addq $0x8, %rsi
movq %rsi, 0x60(%rbx)
addq %r14, %rdx
movq %rdx, 0x68(%rbx)
movzbl 0x5(%r14,%r15), %r9d
movzwl 0x3(%r14,%r15), %edx
rolw $0x8, %dx
movzbl 0x6(%r14,%r15), %esi
movq %rsi, 0x18(%rsp)
movzwl %dx, %esi
movw %si, 0x16(%rbx)
addl $-0x8, %ecx
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %rcx, %rdi
shrq $0x22, %rdi
cmpl %esi, %edi
jae 0x41ea0c
leaq 0x131f58(%rip), %rsi    # 0x55092f
leaq 0x132074(%rip), %rdx    # 0x550a52
leaq 0x131d81(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc16, %ecx           # imm = 0xFC16
xorl %eax, %eax
callq 0x40765d
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, 0x10(%rsp)
addq $0x8, %rax
leal (%rax,%rsi,2), %ecx
movl %ecx, 0x4(%rsp)
leal -0x4(%r13), %r12d
movq 0x8(%rbp), %rcx
testb $0x20, 0x32(%rcx)
je 0x41eaa8
movb 0x8(%rbx), %cl
leal -0x5(%r13), %esi
testb %cl, %cl
cmovel %esi, %r12d
testw %dx, %dx
je 0x41eaa1
movq %r15, 0x8(%rsp)
addq %r14, %rax
incq %rax
movq %rax, 0x20(%rsp)
xorl %r15d, %r15d
movq 0x20(%rsp), %rax
movzwl -0x1(%rax,%r15,2), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
cmpl 0x4(%rsp), %ebp
jb 0x41eb93
cmpl %r12d, %ebp
jg 0x41eb93
movl %ebp, %esi
addq %r14, %rsi
movq %rbx, %rdi
callq *0x78(%rbx)
movzwl %ax, %eax
addl %ebp, %eax
cmpl %r13d, %eax
jg 0x41ebbc
incq %r15
movzwl 0x16(%rbx), %eax
cmpq %rax, %r15
jb 0x41ea4f
movb 0x8(%rbx), %cl
movq 0x8(%rsp), %r15
cmpb $0x1, %cl
adcl $0x0, %r12d
movq 0x10(%rsp), %rax
shll $0x8, %eax
movq 0x18(%rsp), %rcx
addl %ecx, %eax
decl %eax
movzwl %ax, %edx
movzwl 0x1(%r14,%r15), %ecx
rolw $0x8, %cx
incl %edx
movzbl 0x7(%r14,%r15), %eax
addl %edx, %eax
testw %cx, %cx
je 0x41ec15
movzwl %cx, %edx
cmpl 0x4(%rsp), %edx
jae 0x41eb0b
leaq 0x131e46(%rip), %rsi    # 0x55092f
leaq 0x131f62(%rip), %rdx    # 0x550a52
leaq 0x131c6f(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc49, %ecx           # imm = 0xFC49
jmp 0x41e9f4
cmpl %r12d, %edx
jg 0x41eb6a
movl %edx, %ecx
movl %edx, %edx
movzwl (%r14,%rdx), %esi
rolw $0x8, %si
movzwl 0x2(%r14,%rdx), %edi
movzwl %si, %edx
rolw $0x8, %di
movzwl %di, %esi
addl %esi, %eax
leal (%rsi,%rcx), %edi
addl $0x3, %edi
cmpl %edi, %edx
ja 0x41eb0b
testl %edx, %edx
je 0x41ebe5
leaq 0x131de7(%rip), %rsi    # 0x55092f
leaq 0x131f03(%rip), %rdx    # 0x550a52
leaq 0x131c10(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc58, %ecx           # imm = 0xFC58
jmp 0x41e9f4
leaq 0x131dbe(%rip), %rsi    # 0x55092f
leaq 0x131eda(%rip), %rdx    # 0x550a52
leaq 0x131be7(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc4e, %ecx           # imm = 0xFC4E
jmp 0x41e9f4
leaq 0x131d95(%rip), %rsi    # 0x55092f
leaq 0x131eb1(%rip), %rdx    # 0x550a52
leaq 0x131bbe(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc32, %ecx           # imm = 0xFC32
jmp 0x41e9f4
leaq 0x131d6c(%rip), %rsi    # 0x55092f
leaq 0x131e88(%rip), %rdx    # 0x550a52
leaq 0x131b95(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc37, %ecx           # imm = 0xFC37
jmp 0x41e9f4
addl %ecx, %esi
cmpl %r13d, %esi
jbe 0x41ec15
leaq 0x131d3c(%rip), %rsi    # 0x55092f
leaq 0x131e58(%rip), %rdx    # 0x550a52
leaq 0x131b65(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc5c, %ecx           # imm = 0xFC5C
jmp 0x41e9f4
cmpl %r13d, %eax
jle 0x41ec43
leaq 0x131d0e(%rip), %rsi    # 0x55092f
leaq 0x131e2a(%rip), %rdx    # 0x550a52
leaq 0x131b37(%rip), %r8     # 0x550766
movl $0xb, %ebx
movl $0xb, %edi
movl $0xfc68, %ecx           # imm = 0xFC68
jmp 0x41e9f4
subl 0x4(%rsp), %eax
movw %ax, 0x14(%rbx)
movb $0x1, (%rbx)
xorl %ebx, %ebx
jmp 0x41e9fb