; Function compile flags: /Ogtpy
; File D:\10.6\storage\myisam\mi_delete.c
;	COMDAT remove_key
_TEXT	SEGMENT
tv980 = 96
keyinfo$ = 96
nod_flag$ = 104
keypos$ = 112
lastkey$ = 120
page_end$ = 128
next_block$ = 136
remove_key PROC						; COMDAT

; 779  : {

	mov	QWORD PTR [rsp+32], r9
	mov	QWORD PTR [rsp+24], r8
	push	rbp
	push	rbx
	push	rsi
	push	rdi
	push	r12
	push	r13
	push	r14
	mov	rbp, rsp
	sub	rsp, 32					; 00000020H

; 780  :   int s_length;
; 781  :   uchar *start;
; 782  :   DBUG_ENTER("remove_key");
; 783  :   DBUG_PRINT("enter",("keypos: %p  page_end: %p",keypos, page_end));
; 784  : 
; 785  :   start=keypos;
; 786  :   if (!(keyinfo->flag &

	test	BYTE PTR [rcx+10], 46			; 0000002eH
	mov	r13, r9
	mov	r12, QWORD PTR page_end$[rbp-32]
	mov	rsi, r8
	mov	ebx, edx
	mov	r14, rcx
	jne	SHORT $LN11@remove_key

; 787  : 	(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
; 788  : 	 HA_BINARY_PACK_KEY)))
; 789  :   {
; 790  :     s_length=(int) (keyinfo->keylength+nod_flag);

	movzx	edi, WORD PTR [rcx+18]

; 791  :     if (next_block && nod_flag)

	mov	r14, QWORD PTR next_block$[rbp-32]
	add	edi, edx
	test	r14, r14
	je	$end$57
	test	edx, edx
	je	$end$57

; 792  :       *next_block= _mi_kpos(nod_flag,keypos+s_length);

	movsxd	rdx, edi
	mov	ecx, ebx
	add	rdx, r8
	call	_mi_kpos
	mov	QWORD PTR [r14], rax

; 793  :   }

	jmp	$end$57
$LN11@remove_key:

; 794  :   else
; 795  :   {					 /* Let keypos point at next key */
; 796  :     /* Calculate length of key */
; 797  :     if (!(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,lastkey))

	lea	r8, QWORD PTR keypos$[rbp-32]
	call	QWORD PTR [rcx+72]
	test	eax, eax
	jne	SHORT $LN6@remove_key

; 897  : } /* remove_key */

	add	rsp, 32					; 00000020H
	pop	r14
	pop	r13
	pop	r12
	pop	rdi
	pop	rsi
	pop	rbx
	pop	rbp
	ret	0
$LN6@remove_key:

; 798  :       DBUG_RETURN(0);				/* Error */
; 799  : 
; 800  :     if (next_block && nod_flag)

	mov	rdi, QWORD PTR next_block$[rbp-32]
	test	rdi, rdi
	je	SHORT $LN15@remove_key
	test	ebx, ebx
	je	SHORT $LN15@remove_key

; 801  :       *next_block= _mi_kpos(nod_flag,keypos);

	mov	rdx, QWORD PTR keypos$[rbp-32]
	mov	ecx, ebx
	call	_mi_kpos
	mov	QWORD PTR [rdi], rax
$LN15@remove_key:

; 802  :     s_length=(int) (keypos-start);

	mov	rcx, QWORD PTR keypos$[rbp-32]
	mov	edi, ecx
	sub	edi, esi

; 803  :     if (keypos != page_end)

	cmp	rcx, r12
	je	$end$57

; 804  :     {
; 805  :       if (keyinfo->flag & HA_BINARY_PACK_KEY)

	test	BYTE PTR [r14+10], 32			; 00000020H
	mov	QWORD PTR [rsp+104], r15
	je	$LN17@remove_key

; 806  :       {
; 807  : 	uchar *old_key=start;
; 808  : 	uint next_length,prev_length,prev_pack_length;
; 809  : 	get_key_length(next_length,keypos);

	movzx	eax, BYTE PTR [rcx]
	cmp	al, 255					; 000000ffH
	je	SHORT $LN19@remove_key
	mov	r14d, eax
	inc	rcx
	jmp	SHORT $LN53@remove_key
$LN19@remove_key:
	movzx	r14d, BYTE PTR [rcx+1]
	movzx	eax, BYTE PTR [rcx+2]
	shl	r14d, 8
	or	r14d, eax
	add	rcx, 3
$LN53@remove_key:

; 810  : 	get_key_pack_length(prev_length,prev_pack_length,old_key);

	mov	QWORD PTR keypos$[rbp-32], rcx
	movzx	eax, BYTE PTR [rsi]
	cmp	al, 255					; 000000ffH
	je	SHORT $LN21@remove_key
	mov	ebx, eax
	mov	r15d, 1
	jmp	SHORT $LN22@remove_key
$LN21@remove_key:
	movzx	ebx, BYTE PTR [rsi+1]
	mov	r15d, 3
	movzx	eax, BYTE PTR [rsi+2]
	shl	ebx, 8
	or	ebx, eax
$LN22@remove_key:

; 811  : 	if (next_length > prev_length)

	cmp	r14d, ebx
	jbe	$LN52@remove_key

; 812  : 	{
; 813  : 	  /* We have to copy data from the current key to the next key */
; 814  : 	  bmove_upp(keypos, (lastkey+next_length),

	mov	r8d, r14d
	mov	edx, r14d
	sub	r8d, ebx
	add	rdx, r13
	call	bmove_upp

; 815  : 		    (next_length-prev_length));
; 816  : 	  keypos-=(next_length-prev_length)+prev_pack_length;

	mov	rcx, QWORD PTR keypos$[rbp-32]
	sub	r15d, ebx
	lea	eax, DWORD PTR [r14+r15]
	sub	rcx, rax
	mov	QWORD PTR keypos$[rbp-32], rcx

; 817  : 	  store_key_length(keypos,prev_length);

	cmp	ebx, 255				; 000000ffH
	jae	SHORT $LN24@remove_key
	mov	BYTE PTR [rcx], bl

; 818  : 	  s_length=(int) (keypos-start);

	mov	edi, DWORD PTR keypos$[rbp-32]
	sub	edi, esi

; 819  : 	}
; 820  :       }

	jmp	$LN52@remove_key
$LN24@remove_key:

; 817  : 	  store_key_length(keypos,prev_length);

	mov	BYTE PTR [rcx], 255			; 000000ffH
	mov	rax, QWORD PTR keypos$[rbp-32]
	mov	BYTE PTR [rax+2], bl
	mov	rax, QWORD PTR keypos$[rbp-32]
	shr	ebx, 8
	mov	BYTE PTR [rax+1], bl

; 818  : 	  s_length=(int) (keypos-start);

	mov	edi, DWORD PTR keypos$[rbp-32]
	sub	edi, esi

; 819  : 	}
; 820  :       }

	jmp	$LN52@remove_key
$LN17@remove_key:

; 821  :       else
; 822  :       {
; 823  : 	/* Check if a variable length first key part */
; 824  : 	if ((keyinfo->seg->flag & HA_PACK_KEY) && *keypos & 128)

	mov	r9, QWORD PTR [r14+40]
	test	BYTE PTR [r9+18], 2
	je	$LN52@remove_key
	movzx	edx, BYTE PTR [rcx]
	test	dl, dl
	jns	$LN52@remove_key

; 825  : 	{
; 826  : 	  /* Next key is packed against the current one */
; 827  : 	  uint next_length,prev_length,prev_pack_length,lastkey_length,
; 828  : 	    rest_length;
; 829  : 	  if (keyinfo->seg[0].length >= 127)

	cmp	WORD PTR [r9+20], 127			; 0000007fH
	mov	r15d, 1
	movzx	r8d, BYTE PTR [rsi]
	jb	SHORT $LN27@remove_key

; 830  : 	  {
; 831  : 	    if (!(prev_length=mi_uint2korr(start) & 32767))

	movzx	eax, BYTE PTR [rsi+1]
	shl	r8d, 8
	or	r8d, eax
	and	r8d, 32767				; 00007fffH
	je	$LN52@remove_key

; 832  : 	      goto end;
; 833  : 	    next_length=mi_uint2korr(keypos) & 32767;

	movzx	eax, BYTE PTR [rcx+1]

; 834  : 	    keypos+=2;
; 835  : 	    prev_pack_length=2;

	lea	r13d, QWORD PTR [r15+1]
	shl	edx, 8
	or	edx, eax
	and	edx, 32767				; 00007fffH
	add	rcx, 2

; 836  : 	  }

	jmp	SHORT $LN54@remove_key
$LN27@remove_key:

; 837  : 	  else
; 838  : 	  {
; 839  : 	    if (!(prev_length= *start & 127))

	and	r8d, 127				; 0000007fH
	je	$LN52@remove_key

; 840  : 	      goto end;				/* Same key as previous*/
; 841  : 	    next_length= *keypos & 127;

	and	edx, 127				; 0000007fH

; 842  : 	    keypos++;
; 843  : 	    prev_pack_length=1;

	mov	r13d, r15d
	inc	rcx
$LN54@remove_key:

; 844  : 	  }
; 845  : 	  if (!(*start & 128))
; 846  : 	    prev_length=0;			/* prev key not packed */
; 847  : 	  if (keyinfo->seg[0].flag & HA_NULL_PART)
; 848  : 	    lastkey++;				/* Skip null marker */
; 849  : 	  get_key_length(lastkey_length,lastkey);

	mov	rax, QWORD PTR lastkey$[rbp-32]
	xor	ebx, ebx
	mov	QWORD PTR keypos$[rbp-32], rcx
	mov	r10d, ebx
	cmp	BYTE PTR [rsi], bl
	cmovl	r10d, r8d
	test	BYTE PTR [r9+18], 16
	lea	r9, QWORD PTR [rax+1]
	mov	DWORD PTR tv980[rbp-32], r10d
	cmove	r9, rax
	movzx	eax, BYTE PTR [r9]
	lea	r11, QWORD PTR [r9+1]
	cmp	al, 255					; 000000ffH
	je	SHORT $LN33@remove_key
	mov	r8d, eax
	jmp	SHORT $LN34@remove_key
$LN33@remove_key:
	movzx	r8d, BYTE PTR [r11]
	lea	r11, QWORD PTR [r9+3]
	movzx	eax, BYTE PTR [r9+2]
	shl	r8d, 8
	or	r8d, eax
$LN34@remove_key:

; 850  : 	  if (!next_length)			/* Same key after */

	test	edx, edx
	jne	SHORT $LN35@remove_key

; 851  : 	  {
; 852  : 	    next_length=lastkey_length;

	mov	edx, r8d

; 853  : 	    rest_length=0;
; 854  : 	  }

	jmp	SHORT $LN38@remove_key
$LN35@remove_key:

; 855  : 	  else
; 856  : 	    get_key_length(rest_length,keypos);

	movzx	eax, BYTE PTR [rcx]
	cmp	al, 255					; 000000ffH
	je	SHORT $LN37@remove_key
	mov	ebx, eax
	inc	rcx
	jmp	SHORT $LN55@remove_key
$LN37@remove_key:
	movzx	ebx, BYTE PTR [rcx+1]
	movzx	eax, BYTE PTR [rcx+2]
	shl	ebx, 8
	or	ebx, eax
	add	rcx, 3
$LN55@remove_key:

; 857  : 
; 858  : 	  if (next_length >= prev_length)

	mov	QWORD PTR keypos$[rbp-32], rcx
$LN38@remove_key:
	cmp	edx, r10d
	jb	$LN52@remove_key

; 859  : 	  {		/* Key after is based on deleted key */
; 860  : 	    uint pack_length,tmp;
; 861  : 	    bmove_upp(keypos, (lastkey+next_length),

	mov	edi, edx
	add	rdx, r11
	sub	edi, r10d
	mov	r8d, edi
	call	bmove_upp

; 862  : 		      tmp=(next_length-prev_length));
; 863  : 	    rest_length+=tmp;

	add	ebx, edi

; 864  : 	    pack_length= prev_length ? get_pack_length(rest_length): 0;

	cmp	DWORD PTR tv980[rbp-32], 0
	je	SHORT $LN49@remove_key
	mov	rcx, QWORD PTR keypos$[rbp-32]
	mov	eax, r15d
	cmp	ebx, 255				; 000000ffH
	mov	r15d, 3
	cmovae	eax, r15d
	add	eax, r13d
	add	eax, edi
	sub	rcx, rax
	mov	QWORD PTR keypos$[rbp-32], rcx
	mov	edi, ecx

; 865  : 	    keypos-=tmp+pack_length+prev_pack_length;
; 866  : 	    s_length=(int) (keypos-start);
; 867  : 	    if (prev_length)			/* Pack against prev key */
; 868  : 	    {
; 869  : 	      *keypos++= start[0];

	movzx	eax, BYTE PTR [rsi]
	sub	edi, esi
	mov	BYTE PTR [rcx], al
	mov	rcx, QWORD PTR keypos$[rbp-32]
	inc	rcx
	mov	QWORD PTR keypos$[rbp-32], rcx

; 870  : 	      if (prev_pack_length == 2)

	cmp	r13d, 2
	jne	SHORT $LN42@remove_key

; 871  : 		*keypos++= start[1];

	movzx	eax, BYTE PTR [rsi+1]
	mov	BYTE PTR [rcx], al
	mov	rcx, QWORD PTR keypos$[rbp-32]
	inc	rcx
	mov	QWORD PTR keypos$[rbp-32], rcx
$LN42@remove_key:

; 872  : 	      store_key_length(keypos,rest_length);

	cmp	ebx, 255				; 000000ffH
	jae	SHORT $LN43@remove_key
	mov	BYTE PTR [rcx], bl
	jmp	SHORT $LN52@remove_key
$LN43@remove_key:
	mov	BYTE PTR [rcx], 255			; 000000ffH
	mov	rax, QWORD PTR keypos$[rbp-32]
	mov	BYTE PTR [rax+2], bl
	mov	rax, QWORD PTR keypos$[rbp-32]
	shr	ebx, 8
	mov	BYTE PTR [rax+1], bl

; 873  : 	    }

	jmp	SHORT $LN52@remove_key
$LN49@remove_key:

; 864  : 	    pack_length= prev_length ? get_pack_length(rest_length): 0;

	mov	rdx, QWORD PTR keypos$[rbp-32]
	lea	ecx, DWORD PTR [rdi+r13]

; 874  : 	    else
; 875  : 	    {
; 876  : 	      /* Next key is not packed anymore */
; 877  : 	      if (keyinfo->seg[0].flag & HA_NULL_PART)

	mov	rax, QWORD PTR [r14+40]
	sub	rdx, rcx
	mov	edi, edx
	mov	QWORD PTR keypos$[rbp-32], rdx
	sub	edi, esi
	test	BYTE PTR [rax+18], 16
	je	SHORT $LN45@remove_key

; 878  : 	      {
; 879  : 		rest_length++;			/* Mark not null */

	inc	ebx
$LN45@remove_key:

; 880  : 	      }
; 881  : 	      if (prev_pack_length == 2)

	cmp	r13d, 2
	jne	SHORT $LN46@remove_key

; 882  : 	      {
; 883  : 		mi_int2store(keypos,rest_length);

	mov	BYTE PTR [rdx+1], bl
	mov	rax, QWORD PTR keypos$[rbp-32]
	shr	ebx, 8
	mov	BYTE PTR [rax], bl

; 884  : 	      }

	jmp	SHORT $LN52@remove_key
$LN46@remove_key:

; 885  : 	      else
; 886  : 		*keypos= rest_length;

	mov	BYTE PTR [rdx], bl
$LN52@remove_key:
	mov	r15, QWORD PTR [rsp+104]
$end$57:

; 887  : 	    }
; 888  : 	  }
; 889  : 	}
; 890  :       }
; 891  :     }
; 892  :   }
; 893  :   end:
; 894  :   bmove((uchar*) start,(uchar*) start+s_length,

	sub	r12d, esi
	movsxd	rdx, edi
	sub	r12d, edi
	add	rdx, rsi
	mov	r8d, r12d
	mov	rcx, rsi
	call	memmove

; 895  : 	(uint) (page_end-start-s_length));
; 896  :   DBUG_RETURN((uint) s_length);

	mov	eax, edi

; 897  : } /* remove_key */

	add	rsp, 32					; 00000020H
	pop	r14
	pop	r13
	pop	r12
	pop	rdi
	pop	rsi
	pop	rbx
	pop	rbp
	ret	0
remove_key ENDP