// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeRecordCompareWithSkip
SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
  int nKey1, const void *pKey1,   /* Left key */
  UnpackedRecord *pPKey2,         /* Right key */
  int bSkip                       /* If true, skip the first field */
){
  u32 d1;                         /* Offset into aKey[] of next data element */
  int i;                          /* Index of next field to compare */
  u32 szHdr1;                     /* Size of record header in bytes */
  u32 idx1;                       /* Offset of first type in header */
  int rc = 0;                     /* Return value */
  Mem *pRhs = pPKey2->aMem;       /* Next field of pPKey2 to compare */
  KeyInfo *pKeyInfo;
  const unsigned char *aKey1 = (const unsigned char *)pKey1;
  Mem mem1;

  /* If bSkip is true, then the caller has already determined that the first
  ** two elements in the keys are equal. Fix the various stack variables so
  ** that this routine begins comparing at the second field. */
  if( bSkip ){
    u32 s1;
    idx1 = 1 + getVarint32(&aKey1[1], s1);
    szHdr1 = aKey1[0];
    d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1);
    i = 1;
    pRhs++;
  }else{
    idx1 = getVarint32(aKey1, szHdr1);
    d1 = szHdr1;
    i = 0;
  }
  if( d1>(unsigned)nKey1 ){
    pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
    return 0;  /* Corruption */
  }

  VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
  assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
       || CORRUPT_DB );
  assert( pPKey2->pKeyInfo->aSortFlags!=0 );
  assert( pPKey2->pKeyInfo->nKeyField>0 );
  assert( idx1<=szHdr1 || CORRUPT_DB );
  do{
    u32 serial_type;

    /* RHS is an integer */
    if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
      testcase( pRhs->flags & MEM_Int );
      testcase( pRhs->flags & MEM_IntReal );
      serial_type = aKey1[idx1];
      testcase( serial_type==12 );
      if( serial_type>=10 ){
        rc = +1;
      }else if( serial_type==0 ){
        rc = -1;
      }else if( serial_type==7 ){
        sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
        rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
      }else{
        i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
        i64 rhs = pRhs->u.i;
        if( lhs<rhs ){
          rc = -1;
        }else if( lhs>rhs ){
          rc = +1;
        }
      }
    }

    /* RHS is real */
    else if( pRhs->flags & MEM_Real ){
      serial_type = aKey1[idx1];
      if( serial_type>=10 ){
        /* Serial types 12 or greater are strings and blobs (greater than
        ** numbers). Types 10 and 11 are currently "reserved for future
        ** use", so it doesn't really matter what the results of comparing
        ** them to numberic values are.  */
        rc = +1;
      }else if( serial_type==0 ){
        rc = -1;
      }else{
        sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
        if( serial_type==7 ){
          if( mem1.u.r<pRhs->u.r ){
            rc = -1;
          }else if( mem1.u.r>pRhs->u.r ){
            rc = +1;
          }
        }else{
          rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r);
        }
      }
    }

    /* RHS is a string */
    else if( pRhs->flags & MEM_Str ){
      getVarint32NR(&aKey1[idx1], serial_type);
      testcase( serial_type==12 );
      if( serial_type<12 ){
        rc = -1;
      }else if( !(serial_type & 0x01) ){
        rc = +1;
      }else{
        mem1.n = (serial_type - 12) / 2;
        testcase( (d1+mem1.n)==(unsigned)nKey1 );
        testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
        if( (d1+mem1.n) > (unsigned)nKey1
         || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
        ){
          pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
          return 0;                /* Corruption */
        }else if( pKeyInfo->aColl[i] ){
          mem1.enc = pKeyInfo->enc;
          mem1.db = pKeyInfo->db;
          mem1.flags = MEM_Str;
          mem1.z = (char*)&aKey1[d1];
          rc = vdbeCompareMemString(
              &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
          );
        }else{
          int nCmp = MIN(mem1.n, pRhs->n);
          rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
          if( rc==0 ) rc = mem1.n - pRhs->n;
        }
      }
    }

    /* RHS is a blob */
    else if( pRhs->flags & MEM_Blob ){
      assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
      getVarint32NR(&aKey1[idx1], serial_type);
      testcase( serial_type==12 );
      if( serial_type<12 || (serial_type & 0x01) ){
        rc = -1;
      }else{
        int nStr = (serial_type - 12) / 2;
        testcase( (d1+nStr)==(unsigned)nKey1 );
        testcase( (d1+nStr+1)==(unsigned)nKey1 );
        if( (d1+nStr) > (unsigned)nKey1 ){
          pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
          return 0;                /* Corruption */
        }else if( pRhs->flags & MEM_Zero ){
          if( !isAllZero((const char*)&aKey1[d1],nStr) ){
            rc = 1;
          }else{
            rc = nStr - pRhs->u.nZero;
          }
        }else{
          int nCmp = MIN(nStr, pRhs->n);
          rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
          if( rc==0 ) rc = nStr - pRhs->n;
        }
      }
    }

    /* RHS is null */
    else{
      serial_type = aKey1[idx1];
      rc = (serial_type!=0);
    }

    if( rc!=0 ){
      int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
      if( sortFlags ){
        if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0
         || ((sortFlags & KEYINFO_ORDER_DESC)
           !=(serial_type==0 || (pRhs->flags&MEM_Null)))
        ){
          rc = -rc;
        }
      }
      assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) );
      assert( mem1.szMalloc==0 );  /* See comment below */
      return rc;
    }

    i++;
    if( i==pPKey2->nField ) break;
    pRhs++;
    d1 += sqlite3VdbeSerialTypeLen(serial_type);
    idx1 += sqlite3VarintLen(serial_type);
  }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 );

  /* No memory allocation is ever used on mem1.  Prove this using
  ** the following assert().  If the assert() fails, it indicates a
  ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).  */
  assert( mem1.szMalloc==0 );

  /* rc==0 here means that one or both of the keys ran out of fields and
  ** all the fields up to that point were equal. Return the default_rc
  ** value.  */
  assert( CORRUPT_DB
       || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc)
       || pPKey2->pKeyInfo->db->mallocFailed
  );
  pPKey2->eqSeen = 1;
  return pPKey2->default_rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x4028d4
movq -0x48(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jge 0x402868
movq -0x48(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x84(%rbp)
movl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x402885
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
leaq -0x84(%rbp), %rsi
callq 0x3fa520
movzbl %al, %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
movzbl %al, %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0xb0(%rbp)
movl -0x84(%rbp), %edi
callq 0x3fa6e0
movl %eax, %ecx
movl -0xb0(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x38(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x38(%rbp)
jmp 0x402928
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x4028f9
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x40290f
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3fa520
movzbl %al, %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
jbe 0x40294f
movl $0x14147, %edi          # imm = 0x14147
callq 0x3dff80
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x13(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x402f4c
jmp 0x402951
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x24, %eax
cmpl $0x0, %eax
je 0x402a45
movq -0x48(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x88(%rbp)
cmpl $0xa, -0x88(%rbp)
jb 0x40298b
movl $0x1, -0x30(%rbp)
jmp 0x402a40
cmpl $0x0, -0x88(%rbp)
jne 0x4029a0
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x402a3e
cmpl $0x7, -0x88(%rbp)
jne 0x4029de
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movl -0x88(%rbp), %esi
leaq -0x80(%rbp), %rdx
callq 0x3fa720
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movsd -0x80(%rbp), %xmm0
callq 0x400410
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
jmp 0x402a3c
movl -0x88(%rbp), %edi
movq -0x48(%rbp), %rsi
movl -0x20(%rbp), %eax
addq %rax, %rsi
callq 0x402f60
movq %rax, -0x90(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x98(%rbp), %rax
jge 0x402a21
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x402a3a
movq -0x90(%rbp), %rax
cmpq -0x98(%rbp), %rax
jle 0x402a38
movl $0x1, -0x30(%rbp)
jmp 0x402a3a
jmp 0x402a3c
jmp 0x402a3e
jmp 0x402a40
jmp 0x402e26
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x402b06
movq -0x48(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x88(%rbp)
cmpl $0xa, -0x88(%rbp)
jb 0x402a7f
movl $0x1, -0x30(%rbp)
jmp 0x402b01
cmpl $0x0, -0x88(%rbp)
jne 0x402a91
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x402aff
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movl -0x88(%rbp), %esi
leaq -0x80(%rbp), %rdx
callq 0x3fa720
cmpl $0x7, -0x88(%rbp)
jne 0x402ae9
movsd -0x80(%rbp), %xmm1
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x402acf
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x402ae7
movsd -0x80(%rbp), %xmm0
movq -0x38(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x402ae5
movl $0x1, -0x30(%rbp)
jmp 0x402ae7
jmp 0x402afd
movq -0x80(%rbp), %rdi
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
callq 0x400410
movl %eax, -0x30(%rbp)
jmp 0x402aff
jmp 0x402b01
jmp 0x402e24
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x402c9a
movq -0x48(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x88(%rbp)
cmpl $0x80, -0x88(%rbp)
jb 0x402b4d
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %eax
addq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x3fa520
cmpl $0xc, -0x88(%rbp)
jae 0x402b62
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x402c95
movl -0x88(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x402b7c
movl $0x1, -0x30(%rbp)
jmp 0x402c93
movl -0x88(%rbp), %eax
subl $0xc, %eax
shrl %eax
movl %eax, -0x74(%rbp)
movl -0x20(%rbp), %eax
addl -0x74(%rbp), %eax
cmpl -0x8(%rbp), %eax
ja 0x402ba9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movzwl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jg 0x402bc8
movl $0x14194, %edi          # imm = 0x14194
callq 0x3dff80
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x13(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x402f4c
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, 0x20(%rax,%rcx,8)
je 0x402c29
movq -0x40(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0x76(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movw $0x2, -0x78(%rbp)
movq -0x48(%rbp), %rax
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
addq $0x13, %rcx
leaq -0x80(%rbp), %rdi
callq 0x400470
movl %eax, -0x30(%rbp)
jmp 0x402c8f
movl -0x74(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x402c40
movl -0x74(%rbp), %eax
movl %eax, -0xb8(%rbp)
jmp 0x402c4d
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x9c(%rbp), %rdx
callq 0x192c0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x402c8d
movl -0x74(%rbp), %eax
movq -0x38(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x30(%rbp)
jmp 0x402c8f
jmp 0x402c91
jmp 0x402c93
jmp 0x402c95
jmp 0x402e22
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x402dfd
movq -0x48(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x88(%rbp)
cmpl $0x80, -0x88(%rbp)
jb 0x402ce1
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %eax
addq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x3fa520
cmpl $0xc, -0x88(%rbp)
jb 0x402cf8
movl -0x88(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x402d04
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x402dfb
movl -0x88(%rbp), %eax
subl $0xc, %eax
shrl %eax
movl %eax, -0xa0(%rbp)
movl -0x20(%rbp), %eax
addl -0xa0(%rbp), %eax
cmpl -0x8(%rbp), %eax
jbe 0x402d42
movl $0x141b2, %edi          # imm = 0x141B2
callq 0x3dff80
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x13(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x402f4c
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x402d88
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movl -0xa0(%rbp), %esi
callq 0x400720
cmpl $0x0, %eax
jne 0x402d77
movl $0x1, -0x30(%rbp)
jmp 0x402d86
movl -0xa0(%rbp), %eax
movq -0x38(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x30(%rbp)
jmp 0x402df7
movl -0xa0(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x402da5
movl -0xa0(%rbp), %eax
movl %eax, -0xbc(%rbp)
jmp 0x402db2
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0xa4(%rbp), %rdx
callq 0x192c0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x402df5
movl -0xa0(%rbp), %eax
movq -0x38(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x30(%rbp)
jmp 0x402df7
jmp 0x402df9
jmp 0x402dfb
jmp 0x402e20
movq -0x48(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x88(%rbp)
cmpl $0x0, -0x88(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
jmp 0x402e22
jmp 0x402e24
jmp 0x402e26
cmpl $0x0, -0x30(%rbp)
je 0x402ec2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xa8(%rbp)
cmpl $0x0, -0xa8(%rbp)
je 0x402eb7
movl -0xa8(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x402ead
movl -0xa8(%rbp), %eax
andl $0x1, %eax
movl %eax, -0xc4(%rbp)
movb $0x1, %al
cmpl $0x0, -0x88(%rbp)
movb %al, -0xbd(%rbp)
je 0x402e97
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xbd(%rbp)
movl -0xc4(%rbp), %eax
movb -0xbd(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x402eb5
xorl %eax, %eax
subl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x402eb7
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x402f4c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x402edc
jmp 0x402f39
movq -0x38(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x38(%rbp)
movl -0x88(%rbp), %edi
callq 0x3fa6e0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x88(%rbp), %eax
movl %eax, %edi
callq 0x3faa30
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x28(%rbp), %ecx
movb %al, -0xc5(%rbp)
jae 0x402f2b
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
setbe %al
movb %al, -0xc5(%rbp)
movb -0xc5(%rbp), %al
testb $0x1, %al
jne 0x402951
movq -0x18(%rbp), %rax
movb $0x1, 0x16(%rax)
movq -0x18(%rbp), %rax
movsbl 0x12(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)