; Listing generated by Microsoft (R) Optimizing Compiler Version 14.00.50727.762 

	TITLE	d:\Source Code\NC lib\regex\pcre_exec.c
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB LIBCMTD
INCLUDELIB OLDNAMES

CONST	SEGMENT
_rep_min DB	00H
	DB	00H
	DB	01H
	DB	01H
	DB	00H
	DB	00H
	ORG $+2
_rep_max DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	01H
	DB	01H
; Function compile flags: /Ogtpy
; File d:\source code\nc lib\regex\pcre_exec.c
CONST	ENDS
;	COMDAT _match_ref
_TEXT	SEGMENT
_eptr$ = 8						; size = 4
_ims$ = 12						; size = 4
_match_ref PROC						; COMDAT
; _offset$ = edx
; _length$ = eax
; _md$ = ecx

; 139  : {

	push	esi
	mov	esi, eax

; 140  : USPTR p = md->start_subject + md->offset_vector[offset];

	mov	eax, DWORD PTR [ecx+12]
	mov	eax, DWORD PTR [eax+edx*4]

; 141  : 
; 142  : #ifdef DEBUG
; 143  : if (eptr >= md->end_subject)
; 144  :   printf("matching subject <null>");
; 145  : else
; 146  :   {
; 147  :   printf("matching subject ");
; 148  :   pchars(eptr, length, TRUE, md);
; 149  :   }
; 150  : printf(" against backref ");
; 151  : pchars(p, length, FALSE, md);
; 152  : printf("\n");
; 153  : #endif
; 154  : 
; 155  : /* Always fail if not enough characters left */
; 156  : 
; 157  : if (length > md->end_subject - eptr) return FALSE;

	mov	edx, DWORD PTR [ecx+88]
	add	eax, DWORD PTR [ecx+84]
	push	edi
	mov	edi, DWORD PTR _eptr$[esp+4]
	sub	edx, edi
	cmp	esi, edx
	jle	SHORT $LN9@match_ref
	pop	edi
	xor	eax, eax
	pop	esi

; 170  : }

	ret	0
$LN9@match_ref:

; 158  : 
; 159  : /* Separate the caselesss case for speed */
; 160  : 
; 161  : if ((ims & PCRE_CASELESS) != 0)

	test	BYTE PTR _ims$[esp+4], 1
	push	ebx
	je	SHORT $LN13@match_ref

; 162  :   {
; 163  :   while (length-- > 0)

	test	esi, esi
	jle	SHORT $LN17@match_ref
	mov	ecx, DWORD PTR [ecx+36]
	npad	2
$LL7@match_ref:

; 164  :     if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;

	movzx	edx, BYTE PTR [edi]
	movzx	ebx, BYTE PTR [eax]
	mov	dl, BYTE PTR [edx+ecx]
	sub	esi, 1
	add	edi, 1
	add	eax, 1
	cmp	BYTE PTR [ebx+ecx], dl
	jne	SHORT $LN15@match_ref

; 162  :   {
; 163  :   while (length-- > 0)

	test	esi, esi
	jg	SHORT $LL7@match_ref
$LN17@match_ref:
	pop	ebx
	pop	edi

; 168  : 
; 169  : return TRUE;

	mov	eax, 1
	pop	esi

; 170  : }

	ret	0
$LN13@match_ref:

; 165  :   }
; 166  : else
; 167  :   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }

	test	esi, esi
	jle	SHORT $LN17@match_ref
$LL3@match_ref:
	mov	cl, BYTE PTR [eax]
	mov	dl, BYTE PTR [edi]
	sub	esi, 1
	add	edi, 1
	add	eax, 1
	cmp	cl, dl
	jne	SHORT $LN15@match_ref
	test	esi, esi
	jg	SHORT $LL3@match_ref
	pop	ebx
	pop	edi

; 168  : 
; 169  : return TRUE;

	mov	eax, 1
	pop	esi

; 170  : }

	ret	0
$LN15@match_ref:
	pop	ebx
	pop	edi

; 165  :   }
; 166  : else
; 167  :   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }

	xor	eax, eax
	pop	esi

; 170  : }

	ret	0
_match_ref ENDP
_TEXT	ENDS
EXTRN	_pcre_free:DWORD
EXTRN	_pcre_malloc:DWORD
EXTRN	__pcre_OP_lengths:BYTE
EXTRN	__pcre_is_newline:PROC
EXTRN	__pcre_was_newline:PROC
EXTRN	_pcre_callout:DWORD
EXTRN	_memmove:PROC
EXTRN	_memcpy:PROC
; Function compile flags: /Ogtpy
;	COMDAT _match
_TEXT	SEGMENT
_i$ = -228						; size = 4
_save_offset3$ = -228					; size = 4
_max$ = -224						; size = 4
_c$ = -224						; size = 4
_save_offset2$ = -224					; size = 4
tv3629 = -220						; size = 4
_minimize$ = -220					; size = 4
_min$ = -216						; size = 4
_prev$ = -216						; size = 4
_save_offset1$ = -216					; size = 4
_possessive$ = -216					; size = 4
_pp$ = -212						; size = 4
_number$ = -212						; size = 4
tv3580 = -208						; size = 4
_ctype$ = -208						; size = 4
_data$ = -208						; size = 4
_saved_eptr$ = -208					; size = 4
_callpat$ = -208					; size = 4
_offset$ = -208						; size = 4
_op$ = -208						; size = 4
_save_capture_last$ = -204				; size = 4
_original_ims$ = -204					; size = 4
_new_recursive$ = -200					; size = 24
_newptrb$ = -176					; size = 8
_cb$5522 = -168						; size = 48
_stacksave$ = -120					; size = 120
_eptr$ = 8						; size = 4
_ecode$ = 12						; size = 4
_mstart$ = 16						; size = 4
_offset_top$ = 20					; size = 4
_md$ = 24						; size = 4
_ims$ = 28						; size = 4
_eptrb$ = 32						; size = 4
_flags$ = 36						; size = 4
_rdepth$ = 40						; size = 4
_match	PROC						; COMDAT

; 403  : {

	sub	esp, 228				; 000000e4H
	push	ebx
	push	ebp

; 404  : /* These variables do not need to be preserved over recursion in this function,
; 405  : so they can be ordinary variables in all cases. Mark some of them with
; 406  : "register" because they are used a lot in loops. */
; 407  : 
; 408  : register int  rrc;         /* Returns from recursive calls */
; 409  : register int  i;           /* Used for loops not involving calls to RMATCH() */
; 410  : register unsigned int c;   /* Character values not kept over RMATCH() calls */
; 411  : register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
; 412  : 
; 413  : BOOL minimize, possessive; /* Quantifier options */
; 414  : 
; 415  : /* When recursion is not being used, all "local" variables that have to be
; 416  : preserved over calls to RMATCH() are part of a "frame" which is obtained from
; 417  : heap storage. Set up the top-level frame here; others are obtained from the
; 418  : heap whenever RMATCH() does a "recursion". See the macro definitions above. */
; 419  : 
; 420  : #ifdef NO_RECURSE
; 421  : heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
; 422  : frame->Xprevframe = NULL;            /* Marks the top level */
; 423  : 
; 424  : /* Copy in the original argument variables */
; 425  : 
; 426  : frame->Xeptr = eptr;
; 427  : frame->Xecode = ecode;
; 428  : frame->Xmstart = mstart;
; 429  : frame->Xoffset_top = offset_top;
; 430  : frame->Xims = ims;
; 431  : frame->Xeptrb = eptrb;
; 432  : frame->Xflags = flags;
; 433  : frame->Xrdepth = rdepth;
; 434  : 
; 435  : /* This is where control jumps back to to effect "recursion" */
; 436  : 
; 437  : HEAP_RECURSE:
; 438  : 
; 439  : /* Macros make the argument variables come from the current frame */
; 440  : 
; 441  : #define eptr               frame->Xeptr
; 442  : #define ecode              frame->Xecode
; 443  : #define mstart             frame->Xmstart
; 444  : #define offset_top         frame->Xoffset_top
; 445  : #define ims                frame->Xims
; 446  : #define eptrb              frame->Xeptrb
; 447  : #define flags              frame->Xflags
; 448  : #define rdepth             frame->Xrdepth
; 449  : 
; 450  : /* Ditto for the local variables */
; 451  : 
; 452  : #ifdef SUPPORT_UTF8
; 453  : #define charptr            frame->Xcharptr
; 454  : #endif
; 455  : #define callpat            frame->Xcallpat
; 456  : #define data               frame->Xdata
; 457  : #define next               frame->Xnext
; 458  : #define pp                 frame->Xpp
; 459  : #define prev               frame->Xprev
; 460  : #define saved_eptr         frame->Xsaved_eptr
; 461  : 
; 462  : #define new_recursive      frame->Xnew_recursive
; 463  : 
; 464  : #define cur_is_word        frame->Xcur_is_word
; 465  : #define condition          frame->Xcondition
; 466  : #define prev_is_word       frame->Xprev_is_word
; 467  : 
; 468  : #define original_ims       frame->Xoriginal_ims
; 469  : 
; 470  : #ifdef SUPPORT_UCP
; 471  : #define prop_type          frame->Xprop_type
; 472  : #define prop_value         frame->Xprop_value
; 473  : #define prop_fail_result   frame->Xprop_fail_result
; 474  : #define prop_category      frame->Xprop_category
; 475  : #define prop_chartype      frame->Xprop_chartype
; 476  : #define prop_script        frame->Xprop_script
; 477  : #define oclength           frame->Xoclength
; 478  : #define occhars            frame->Xocchars
; 479  : #endif
; 480  : 
; 481  : #define ctype              frame->Xctype
; 482  : #define fc                 frame->Xfc
; 483  : #define fi                 frame->Xfi
; 484  : #define length             frame->Xlength
; 485  : #define max                frame->Xmax
; 486  : #define min                frame->Xmin
; 487  : #define number             frame->Xnumber
; 488  : #define offset             frame->Xoffset
; 489  : #define op                 frame->Xop
; 490  : #define save_capture_last  frame->Xsave_capture_last
; 491  : #define save_offset1       frame->Xsave_offset1
; 492  : #define save_offset2       frame->Xsave_offset2
; 493  : #define save_offset3       frame->Xsave_offset3
; 494  : #define stacksave          frame->Xstacksave
; 495  : 
; 496  : #define newptrb            frame->Xnewptrb
; 497  : 
; 498  : /* When recursion is being used, local variables are allocated on the stack and
; 499  : get preserved during recursion in the normal way. In this environment, fi and
; 500  : i, and fc and c, can be the same variables. */
; 501  : 
; 502  : #else         /* NO_RECURSE not defined */
; 503  : #define fi i
; 504  : #define fc c
; 505  : 
; 506  : 
; 507  : #ifdef SUPPORT_UTF8                /* Many of these variables are used only  */
; 508  : const uschar *charptr;             /* in small blocks of the code. My normal */
; 509  : #endif                             /* style of coding would have declared    */
; 510  : const uschar *callpat;             /* them within each of those blocks.      */
; 511  : const uschar *data;                /* However, in order to accommodate the   */
; 512  : const uschar *next;                /* version of this code that uses an      */
; 513  : USPTR         pp;                  /* external "stack" implemented on the    */
; 514  : const uschar *prev;                /* heap, it is easier to declare them all */
; 515  : USPTR         saved_eptr;          /* here, so the declarations can be cut   */
; 516  :                                    /* out in a block. The only declarations  */
; 517  : recursion_info new_recursive;      /* within blocks below are for variables  */
; 518  :                                    /* that do not have to be preserved over  */
; 519  : BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
; 520  : BOOL condition;
; 521  : BOOL prev_is_word;
; 522  : 
; 523  : unsigned long int original_ims;
; 524  : 
; 525  : #ifdef SUPPORT_UCP
; 526  : int prop_type;
; 527  : int prop_value;
; 528  : int prop_fail_result;
; 529  : int prop_category;
; 530  : int prop_chartype;
; 531  : int prop_script;
; 532  : int oclength;
; 533  : uschar occhars[8];
; 534  : #endif
; 535  : 
; 536  : int ctype;
; 537  : int length;
; 538  : int max;
; 539  : int min;
; 540  : int number;
; 541  : int offset;
; 542  : int op;
; 543  : int save_capture_last;
; 544  : int save_offset1, save_offset2, save_offset3;
; 545  : int stacksave[REC_STACK_SAVE_MAX];
; 546  : 
; 547  : eptrblock newptrb;
; 548  : #endif     /* NO_RECURSE */
; 549  : 
; 550  : /* These statements are here to stop the compiler complaining about unitialized
; 551  : variables. */
; 552  : 
; 553  : #ifdef SUPPORT_UCP
; 554  : prop_value = 0;
; 555  : prop_fail_result = 0;
; 556  : #endif
; 557  : 
; 558  : 
; 559  : /* This label is used for tail recursion, which is used in a few cases even
; 560  : when NO_RECURSE is not defined, in order to reduce the amount of stack that is
; 561  : used. Thanks to Ian Taylor for noticing this possibility and sending the
; 562  : original patch. */
; 563  : 
; 564  : TAIL_RECURSE:
; 565  : 
; 566  : /* OK, now we can get on with the real code of the function. Recursive calls
; 567  : are specified by the macro RMATCH and RRETURN is used to return. When
; 568  : NO_RECURSE is *not* defined, these just turn into a recursive call to match()
; 569  : and a "return", respectively (possibly with some debugging if DEBUG is
; 570  : defined). However, RMATCH isn't like a function call because it's quite a
; 571  : complicated macro. It has to be used in one particular way. This shouldn't,
; 572  : however, impact performance when true recursion is being used. */
; 573  : 
; 574  : #ifdef SUPPORT_UTF8
; 575  : utf8 = md->utf8;       /* Local copy of the flag */
; 576  : #else
; 577  : utf8 = FALSE;
; 578  : #endif
; 579  : 
; 580  : /* First check that we haven't called match() too many times, or that we
; 581  : haven't exceeded the recursive call limit. */
; 582  : 
; 583  : if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);

	mov	ebp, DWORD PTR _md$[esp+232]
	mov	eax, DWORD PTR [ebp]
	cmp	eax, DWORD PTR [ebp+4]
	push	esi
	push	edi
	jae	$LN1325@match
	mov	edi, DWORD PTR _ecode$[esp+240]
	mov	esi, DWORD PTR _eptr$[esp+240]
	npad	5
$TAIL_RECURSE$5435:

; 584  : if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	add	DWORD PTR [ebp], 1
	cmp	ecx, DWORD PTR [ebp+8]
	jae	$LN943@match

; 585  : 
; 586  : original_ims = ims;    /* Save for resetting on ')' */
; 587  : 
; 588  : /* At the start of a group with an unlimited repeat that may match an empty
; 589  : string, the match_cbegroup flag is set. When this is the case, add the current
; 590  : subject pointer to the chain of such remembered pointers, to be checked when we
; 591  : hit the closing ket, in order to break infinite loops that match no characters.
; 592  : When match() is called in other circumstances, don't add to the chain. The
; 593  : match_cbegroup flag must NOT be used with tail recursion, because the memory
; 594  : block that is used is on the stack, so a new one may be required for each
; 595  : match(). */
; 596  : 
; 597  : if ((flags & match_cbegroup) != 0)

	test	BYTE PTR _flags$[esp+240], 2
	mov	edx, DWORD PTR _ims$[esp+240]
	mov	DWORD PTR _original_ims$[esp+244], edx
	je	SHORT $LL650@match

; 598  :   {
; 599  :   newptrb.epb_saved_eptr = eptr;
; 600  :   newptrb.epb_prev = eptrb;

	mov	eax, DWORD PTR _eptrb$[esp+240]

; 601  :   eptrb = &newptrb;

	lea	ecx, DWORD PTR _newptrb$[esp+244]
	mov	DWORD PTR _newptrb$[esp+248], esi
	mov	DWORD PTR _newptrb$[esp+244], eax
	mov	DWORD PTR _eptrb$[esp+240], ecx
$LL650@match:

; 602  :   }
; 603  : 
; 604  : /* Now start processing the opcodes. */
; 605  : 
; 606  : for (;;)
; 607  :   {
; 608  :   minimize = possessive = FALSE;
; 609  :   op = *ecode;

	movzx	ecx, BYTE PTR [edi]
	xor	edx, edx

; 610  : 
; 611  :   /* For partial matching, remember if we ever hit the end of the subject after
; 612  :   matching at least one subject character. */
; 613  : 
; 614  :   if (md->partial &&
; 615  :       eptr >= md->end_subject &&
; 616  :       eptr > mstart)

	cmp	DWORD PTR [ebp+68], edx
	mov	DWORD PTR _possessive$[esp+244], edx
	mov	DWORD PTR _minimize$[esp+244], edx
	mov	DWORD PTR _op$[esp+244], ecx
	je	SHORT $LN1309@match
	cmp	esi, DWORD PTR [ebp+88]
	jb	SHORT $LN1309@match
	mov	ebx, DWORD PTR _mstart$[esp+240]
	cmp	esi, ebx
	jbe	SHORT $LN1310@match

; 617  :     md->hitend = TRUE;

	mov	DWORD PTR [ebp+72], 1
	jmp	SHORT $LN1310@match
$LN1309@match:
	mov	ebx, DWORD PTR _mstart$[esp+240]
$LN1310@match:

; 618  : 
; 619  :   switch(op)

	cmp	ecx, 109				; 0000006dH
	ja	$LN91@match
	movzx	eax, BYTE PTR $LN1242@match[ecx]
	jmp	DWORD PTR $LN1432@match[eax*4]
$LN628@match:

; 751  :       }
; 752  :     /* Control never reaches here. */
; 753  : 
; 754  :     /* Conditional group: compilation checked that there are no more than
; 755  :     two branches. If the condition is false, skipping the first branch takes us
; 756  :     past the end if there is only one branch, but that's OK because that is
; 757  :     exactly what going to the ket would do. As there is only one branch to be
; 758  :     obeyed, we can use tail recursion to avoid using another stack frame. */
; 759  : 
; 760  :     case OP_COND:
; 761  :     case OP_SCOND:
; 762  :     if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */

	mov	cl, BYTE PTR [edi+3]
	cmp	cl, 100					; 00000064H
	lea	eax, DWORD PTR [edi+3]
	jne	SHORT $LN623@match

; 763  :       {
; 764  :       offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
; 765  :       condition = md->recursive != NULL &&
; 766  :         (offset == RREF_ANY || offset == md->recursive->group_num);

	mov	eax, DWORD PTR [ebp+120]
	xor	ecx, ecx
	test	eax, eax
	mov	ch, BYTE PTR [edi+4]
	mov	cl, BYTE PTR [edi+5]
	je	SHORT $LN1341@match
	cmp	ecx, 65535				; 0000ffffH
	je	SHORT $LN656@match
	cmp	ecx, DWORD PTR [eax+4]
	jne	SHORT $LN1341@match
$LN656@match:
	mov	ecx, 1

; 774  :       ecode += condition? 3 : GET(ecode, 1);

	lea	eax, DWORD PTR [ecx+2]
	jmp	SHORT $LN664@match
$LN623@match:

; 767  :       ecode += condition? 3 : GET(ecode, 1);
; 768  :       }
; 769  : 
; 770  :     else if (ecode[LINK_SIZE+1] == OP_CREF)    /* Group used test */

	cmp	cl, 99					; 00000063H
	jne	SHORT $LN621@match

; 771  :       {
; 772  :       offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */

	xor	eax, eax
	mov	ah, BYTE PTR [edi+4]
	mov	al, BYTE PTR [edi+5]
	add	eax, eax

; 773  :       condition = offset < offset_top && md->offset_vector[offset] >= 0;

	cmp	eax, DWORD PTR _offset_top$[esp+240]
	jge	SHORT $LN1341@match
	mov	ecx, DWORD PTR [ebp+12]
	cmp	DWORD PTR [ecx+eax*4], 0
	jge	SHORT $LN656@match
$LN1341@match:
	xor	ecx, ecx

; 774  :       ecode += condition? 3 : GET(ecode, 1);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
$LN664@match:
	add	edi, eax

; 805  :         }
; 806  :       }
; 807  : 
; 808  :     /* We are now at the branch that is to be obeyed. As there is only one,
; 809  :     we can use tail recursion to avoid using another stack frame, except when
; 810  :     match_cbegroup is required for an unlimited repeat of a possibly empty
; 811  :     group. If the second alternative doesn't exist, we can just plough on. */
; 812  : 
; 813  :     if (condition || *ecode == OP_ALT)

	test	ecx, ecx
	jne	$LN1316@match
$LN1107@match:
	cmp	BYTE PTR [edi], 83			; 00000053H
	je	$LN1316@match

; 819  :         RRETURN(rrc);
; 820  :         }
; 821  :       else                       /* Group must match something */
; 822  :         {
; 823  :         flags = 0;
; 824  :         goto TAIL_RECURSE;
; 825  :         }
; 826  :       }
; 827  :     else                         /* Condition false & no 2nd alternative */
; 828  :       {
; 829  :       ecode += 1 + LINK_SIZE;

	add	edi, 3

; 830  :       }
; 831  :     break;

	jmp	$LL650@match
$LN621@match:

; 775  :       }
; 776  : 
; 777  :     else if (ecode[LINK_SIZE+1] == OP_DEF)     /* DEFINE - always false */

	cmp	cl, 101					; 00000065H
	jne	SHORT $LN619@match

; 778  :       {
; 779  :       condition = FALSE;
; 780  :       ecode += GET(ecode, 1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	mov	dl, BYTE PTR [edi+2]
	add	edi, edx

; 781  :       }
; 782  : 
; 783  :     /* The condition is an assertion. Call match() to evaluate it - setting
; 784  :     the final argument match_condassert causes it to stop at the end of an
; 785  :     assertion. */
; 786  : 
; 787  :     else

	jmp	SHORT $LN1107@match
$LN619@match:

; 788  :       {
; 789  :       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
; 790  :           match_condassert, RM3);

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	add	ecx, 1
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+244]
	push	1
	push	0
	push	edx
	push	ebp
	push	ecx
	push	ebx
	push	eax
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 791  :       if (rrc == MATCH_MATCH)

	cmp	eax, 1
	je	$LN1181@match

; 796  :         }
; 797  :       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)

	test	eax, eax
	je	SHORT $LN613@match
	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN613@match:

; 798  :         {
; 799  :         RRETURN(rrc);         /* Need braces because of following else */
; 800  :         }
; 801  :       else
; 802  :         {
; 803  :         condition = FALSE;
; 804  :         ecode += GET(ecode, 1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	mov	dl, BYTE PTR [edi+2]
	add	edi, edx

; 805  :         }
; 806  :       }
; 807  : 
; 808  :     /* We are now at the branch that is to be obeyed. As there is only one,
; 809  :     we can use tail recursion to avoid using another stack frame, except when
; 810  :     match_cbegroup is required for an unlimited repeat of a possibly empty
; 811  :     group. If the second alternative doesn't exist, we can just plough on. */
; 812  : 
; 813  :     if (condition || *ecode == OP_ALT)

	jmp	SHORT $LN1107@match
$LN606@match:

; 832  : 
; 833  : 
; 834  :     /* End of the pattern, either real or forced. If we are in a top-level
; 835  :     recursion, we should restore the offsets appropriately and continue from
; 836  :     after the call. */
; 837  : 
; 838  :     case OP_ACCEPT:
; 839  :     case OP_END:
; 840  :     if (md->recursive != NULL && md->recursive->group_num == 0)

	mov	edi, DWORD PTR [ebp+120]
	test	edi, edi
	je	$LN605@match
	cmp	DWORD PTR [edi+4], 0
	jne	$LN605@match

; 841  :       {
; 842  :       recursion_info *rec = md->recursive;
; 843  :       DPRINTF(("End of pattern in a (?0) recursion\n"));
; 844  :       md->recursive = rec->prevrec;

	mov	eax, DWORD PTR [edi]
	mov	DWORD PTR [ebp+120], eax

; 845  :       memmove(md->offset_vector, rec->offset_save,
; 846  :         rec->saved_max * sizeof(int));

	mov	ecx, DWORD PTR [edi+20]
	mov	edx, DWORD PTR [edi+16]
	mov	eax, DWORD PTR [ebp+12]
	add	ecx, ecx
	add	ecx, ecx
	push	ecx
	push	edx
	push	eax
	call	_memmove

; 847  :       mstart = rec->save_start;

	mov	ecx, DWORD PTR [edi+12]

; 848  :       ims = original_ims;

	mov	edx, DWORD PTR _original_ims$[esp+256]

; 849  :       ecode = rec->after_call;

	mov	edi, DWORD PTR [edi+8]
	add	esp, 12					; 0000000cH
	mov	DWORD PTR _mstart$[esp+240], ecx
	mov	DWORD PTR _ims$[esp+240], edx

; 850  :       break;

	jmp	$LL650@match
$LN603@match:

; 861  : 
; 862  :     /* Change option settings */
; 863  : 
; 864  :     case OP_OPT:
; 865  :     ims = ecode[1];

	movzx	eax, BYTE PTR [edi+1]
	mov	DWORD PTR _ims$[esp+240], eax

; 866  :     ecode += 2;

	add	edi, 2

; 867  :     DPRINTF(("ims set to %02lx\n", ims));
; 868  :     break;

	jmp	$LL650@match
$LN1117@match:
	mov	ecx, DWORD PTR _rdepth$[esp+240]
	add	ecx, 1
	mov	DWORD PTR tv3629[esp+244], ecx
	npad	9
$LL601@match:

; 869  : 
; 870  :     /* Assertion brackets. Check the alternative branches in turn - the
; 871  :     matching won't pass the KET for an assertion. If any one branch matches,
; 872  :     the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
; 873  :     start of each branch to move the current point backwards, so the code at
; 874  :     this level is identical to the lookahead case. */
; 875  : 
; 876  :     case OP_ASSERT:
; 877  :     case OP_ASSERTBACK:
; 878  :     do
; 879  :       {
; 880  :       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
; 881  :         RM4);

	mov	edx, DWORD PTR tv3629[esp+244]
	mov	eax, DWORD PTR _ims$[esp+240]
	mov	ecx, DWORD PTR _offset_top$[esp+240]
	push	edx
	push	0
	push	0
	push	eax
	push	ebp
	push	ecx
	push	ebx
	lea	edx, DWORD PTR [edi+3]
	push	edx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 882  :       if (rrc == MATCH_MATCH) break;

	cmp	eax, 1
	je	SHORT $LN599@match

; 883  :       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);

	test	eax, eax
	je	SHORT $LN597@match
	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN597@match:

; 884  :       ecode += GET(ecode, 1);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
	add	edi, eax

; 885  :       }
; 886  :     while (*ecode == OP_ALT);

	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL601@match
$LN599@match:

; 887  :     if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);

	cmp	BYTE PTR [edi], 84			; 00000054H
	je	$LN645@match

; 888  : 
; 889  :     /* If checking an assertion for a condition, return MATCH_MATCH. */
; 890  : 
; 891  :     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);

	test	BYTE PTR _flags$[esp+240], 1
	jne	$LN880@match
$LL594@match:

; 892  : 
; 893  :     /* Continue from after the assertion, updating the offsets high water
; 894  :     mark, since extracts may have been taken during the assertion. */
; 895  : 
; 896  :     do ecode += GET(ecode,1); while (*ecode == OP_ALT);

	xor	ecx, ecx
	mov	ch, BYTE PTR [edi+1]
	mov	cl, BYTE PTR [edi+2]
	add	edi, ecx
	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL594@match

; 897  :     ecode += 1 + LINK_SIZE;
; 898  :     offset_top = md->end_offset_top;

	mov	edx, DWORD PTR [ebp+100]
	add	edi, 3
	mov	DWORD PTR _offset_top$[esp+240], edx

; 899  :     continue;

	jmp	$LL650@match
$LN1119@match:
	mov	eax, DWORD PTR _rdepth$[esp+240]
	add	eax, 1
	mov	DWORD PTR tv3629[esp+244], eax
$LL590@match:

; 900  : 
; 901  :     /* Negative assertion: all branches must fail to match */
; 902  : 
; 903  :     case OP_ASSERT_NOT:
; 904  :     case OP_ASSERTBACK_NOT:
; 905  :     do
; 906  :       {
; 907  :       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
; 908  :         RM5);

	mov	ecx, DWORD PTR tv3629[esp+244]
	mov	edx, DWORD PTR _ims$[esp+240]
	mov	eax, DWORD PTR _offset_top$[esp+240]
	push	ecx
	push	0
	push	0
	push	edx
	push	ebp
	push	eax
	push	ebx
	lea	ecx, DWORD PTR [edi+3]
	push	ecx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 909  :       if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);

	cmp	eax, 1
	je	$LN645@match

; 910  :       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);

	test	eax, eax
	je	SHORT $LN586@match
	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN586@match:

; 911  :       ecode += GET(ecode,1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	mov	dl, BYTE PTR [edi+2]
	add	edi, edx

; 912  :       }
; 913  :     while (*ecode == OP_ALT);

	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL590@match

; 914  : 
; 915  :     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);

	test	BYTE PTR _flags$[esp+240], 1
	jne	$LN880@match

; 916  : 
; 917  :     ecode += 1 + LINK_SIZE;

	add	edi, 3

; 918  :     continue;

	jmp	$LL650@match
$LN584@match:

; 919  : 
; 920  :     /* Move the subject pointer back. This occurs only at the start of
; 921  :     each branch of a lookbehind assertion. If we are too close to the start to
; 922  :     move back, this match function fails. When working with UTF-8 we move
; 923  :     back a number of characters, not bytes. */
; 924  : 
; 925  :     case OP_REVERSE:
; 926  : #ifdef SUPPORT_UTF8
; 927  :     if (utf8)
; 928  :       {
; 929  :       i = GET(ecode, 1);
; 930  :       while (i-- > 0)
; 931  :         {
; 932  :         eptr--;
; 933  :         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
; 934  :         BACKCHAR(eptr);
; 935  :         }
; 936  :       }
; 937  :     else
; 938  : #endif
; 939  : 
; 940  :     /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
; 941  : 
; 942  :       {
; 943  :       eptr -= GET(ecode, 1);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
	sub	esi, eax

; 944  :       if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+84]
	jb	$LN645@match

; 945  :       }
; 946  : 
; 947  :     /* Skip to next op code */
; 948  : 
; 949  :     ecode += 1 + LINK_SIZE;

	add	edi, 3

; 950  :     break;

	jmp	$LL650@match
$LN582@match:

; 951  : 
; 952  :     /* The callout item calls an external function, if one is provided, passing
; 953  :     details of the match so far. This is mainly for debugging, though the
; 954  :     function is able to force a failure. */
; 955  : 
; 956  :     case OP_CALLOUT:
; 957  :     if (pcre_callout != NULL)

	mov	ecx, DWORD PTR _pcre_callout
	test	ecx, ecx
	je	$LN579@match

; 958  :       {
; 959  :       pcre_callout_block cb;
; 960  :       cb.version          = 1;   /* Version 1 of the callout block */
; 961  :       cb.callout_number   = ecode[1];

	movzx	edx, BYTE PTR [edi+1]

; 962  :       cb.offset_vector    = md->offset_vector;

	mov	eax, DWORD PTR [ebp+12]
	mov	DWORD PTR _cb$5522[esp+252], eax

; 963  :       cb.subject          = (PCRE_SPTR)md->start_subject;

	mov	eax, DWORD PTR [ebp+84]
	mov	DWORD PTR _cb$5522[esp+248], edx

; 964  :       cb.subject_length   = md->end_subject - md->start_subject;

	mov	edx, DWORD PTR [ebp+88]
	sub	edx, eax
	mov	DWORD PTR _cb$5522[esp+260], edx

; 965  :       cb.start_match      = mstart - md->start_subject;

	sub	ebx, eax
	mov	DWORD PTR _cb$5522[esp+256], eax

; 966  :       cb.current_position = eptr - md->start_subject;

	mov	edx, esi
	sub	edx, eax

; 967  :       cb.pattern_position = GET(ecode, 2);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+2]
	mov	DWORD PTR _cb$5522[esp+268], edx

; 968  :       cb.next_item_length = GET(ecode, 2 + LINK_SIZE);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+4]
	mov	DWORD PTR _cb$5522[esp+244], 1
	mov	DWORD PTR _cb$5522[esp+264], ebx
	mov	al, BYTE PTR [edi+3]
	mov	dl, BYTE PTR [edi+5]
	mov	DWORD PTR _cb$5522[esp+284], eax

; 969  :       cb.capture_top      = offset_top/2;

	mov	eax, DWORD PTR _offset_top$[esp+240]
	mov	DWORD PTR _cb$5522[esp+288], edx
	cdq
	sub	eax, edx

; 970  :       cb.capture_last     = md->capture_last;
; 971  :       cb.callout_data     = md->callout_data;

	mov	edx, DWORD PTR [ebp+124]
	sar	eax, 1
	mov	DWORD PTR _cb$5522[esp+272], eax
	mov	eax, DWORD PTR [ebp+104]
	mov	DWORD PTR _cb$5522[esp+276], eax

; 972  :       if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);

	lea	eax, DWORD PTR _cb$5522[esp+244]
	push	eax
	mov	DWORD PTR _cb$5522[esp+284], edx
	call	ecx
	add	esp, 4
	test	eax, eax
	jg	$LN645@match

; 973  :       if (rrc < 0) RRETURN(rrc);

	jl	$LN649@match
$LN579@match:

; 974  :       }
; 975  :     ecode += 2 + 2*LINK_SIZE;

	add	edi, 6

; 976  :     break;

	jmp	$LL650@match
$LN566@match:

; 1065 :       }
; 1066 :     /* Control never reaches here */
; 1067 : 
; 1068 :     /* "Once" brackets are like assertion brackets except that after a match,
; 1069 :     the point in the subject string is not moved back. Thus there can never be
; 1070 :     a move back into the brackets. Friedl calls these "atomic" subpatterns.
; 1071 :     Check the alternative branches in turn - the matching won't pass the KET
; 1072 :     for this kind of subpattern. If any one branch matches, we carry on as at
; 1073 :     the end of a normal bracket, leaving the subject pointer. */
; 1074 : 
; 1075 :     case OP_ONCE:
; 1076 :     prev = ecode;

	mov	DWORD PTR _prev$[esp+244], edi

; 1077 :     saved_eptr = eptr;

	mov	DWORD PTR _saved_eptr$[esp+244], esi
$LL565@match:

; 1078 : 
; 1079 :     do
; 1080 :       {
; 1081 :       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);

	mov	eax, DWORD PTR _rdepth$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	add	eax, 1
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+244]
	push	0
	push	ecx
	push	edx
	push	ebp
	push	eax
	push	ebx
	lea	ecx, DWORD PTR [edi+3]
	push	ecx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1082 :       if (rrc == MATCH_MATCH) break;

	cmp	eax, 1
	je	SHORT $LN563@match

; 1083 :       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);

	test	eax, eax
	je	SHORT $LN561@match
	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN561@match:

; 1084 :       ecode += GET(ecode,1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	mov	dl, BYTE PTR [edi+2]
	add	edi, edx

; 1085 :       }
; 1086 :     while (*ecode == OP_ALT);

	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL565@match
$LN563@match:

; 1087 : 
; 1088 :     /* If hit the end of the group (which could be repeated), fail */
; 1089 : 
; 1090 :     if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);

	mov	al, BYTE PTR [edi]
	cmp	al, 92					; 0000005cH
	je	SHORT $LL559@match
	cmp	al, 83					; 00000053H
	jne	$LN645@match
$LL559@match:

; 1091 : 
; 1092 :     /* Continue as from after the assertion, updating the offsets high water
; 1093 :     mark, since extracts may have been taken. */
; 1094 : 
; 1095 :     do ecode += GET(ecode, 1); while (*ecode == OP_ALT);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
	add	edi, eax
	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL559@match

; 1096 : 
; 1097 :     offset_top = md->end_offset_top;
; 1098 :     eptr = md->end_match_ptr;
; 1099 : 
; 1100 :     /* For a non-repeating ket, just continue at this level. This also
; 1101 :     happens for a repeating ket if no characters were matched in the group.
; 1102 :     This is the forcible breaking of infinite loops as implemented in Perl
; 1103 :     5.005. If there is an options reset, it will get obeyed in the normal
; 1104 :     course of events. */
; 1105 : 
; 1106 :     if (*ecode == OP_KET || eptr == saved_eptr)

	cmp	BYTE PTR [edi], 84			; 00000054H
	mov	eax, DWORD PTR [ebp+100]
	mov	esi, DWORD PTR [ebp+96]
	mov	DWORD PTR _offset_top$[esp+240], eax
	je	SHORT $LN555@match
	cmp	esi, DWORD PTR _saved_eptr$[esp+244]
	jne	$LN556@match
$LN555@match:

; 1107 :       {
; 1108 :       ecode += 1+LINK_SIZE;

	add	edi, 3

; 1109 :       break;

	jmp	$LL650@match
	npad	6
$LL548@match:

; 1139 :       }
; 1140 :     /* Control never gets here */
; 1141 : 
; 1142 :     /* An alternation is the end of a branch; scan along to find the end of the
; 1143 :     bracketed group and go to there. */
; 1144 : 
; 1145 :     case OP_ALT:
; 1146 :     do ecode += GET(ecode,1); while (*ecode == OP_ALT);

	xor	ecx, ecx
	mov	ch, BYTE PTR [edi+1]
	mov	cl, BYTE PTR [edi+2]
	add	edi, ecx
	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL548@match

; 1147 :     break;

	jmp	$LL650@match
$LN545@match:

; 1148 : 
; 1149 :     /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
; 1150 :     that it may occur zero times. It may repeat infinitely, or not at all -
; 1151 :     i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
; 1152 :     repeat limits are compiled as a number of copies, with the optional ones
; 1153 :     preceded by BRAZERO or BRAMINZERO. */
; 1154 : 
; 1155 :     case OP_BRAZERO:
; 1156 :       {
; 1157 :       next = ecode+1;
; 1158 :       RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);

	mov	edx, DWORD PTR _rdepth$[esp+240]
	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	add	edx, 1
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	eax
	push	ecx
	push	ebp
	push	edx
	push	ebx
	add	edi, 1
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1159 :       if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
$LL543@match:

; 1160 :       do next += GET(next,1); while (*next == OP_ALT);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
	add	edi, eax
	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL543@match

; 1161 :       ecode = next + 1 + LINK_SIZE;

	add	edi, 3

; 1162 :       }
; 1163 :     break;

	jmp	$LL650@match
$LN540@match:

; 1164 : 
; 1165 :     case OP_BRAMINZERO:
; 1166 :       {
; 1167 :       next = ecode+1;

	add	edi, 1
	mov	eax, edi
	npad	4
$LL539@match:

; 1168 :       do next += GET(next, 1); while (*next == OP_ALT);

	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+1]
	mov	cl, BYTE PTR [eax+2]
	add	eax, ecx
	cmp	BYTE PTR [eax], 83			; 00000053H
	je	SHORT $LL539@match

; 1169 :       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0, RM11);

	mov	edx, DWORD PTR _rdepth$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	add	edx, 1
	push	edx
	mov	edx, DWORD PTR _ims$[esp+244]
	push	0
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+252]
	push	edx
	push	ebp
	push	ecx
	push	ebx
	add	eax, 3
	push	eax
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1170 :       if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1171 :       ecode++;
; 1172 :       }
; 1173 :     break;

	jmp	$LL650@match
$LN535@match:

; 1174 : 
; 1175 :     /* End of a group, repeated or non-repeating. */
; 1176 : 
; 1177 :     case OP_KET:
; 1178 :     case OP_KETRMIN:
; 1179 :     case OP_KETRMAX:
; 1180 :     prev = ecode - GET(ecode, 1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	mov	ecx, edi
	mov	dl, BYTE PTR [edi+2]
	sub	ecx, edx

; 1181 : 
; 1182 :     /* If this was a group that remembered the subject start, in order to break
; 1183 :     infinite repeats of empty string matches, retrieve the subject start from
; 1184 :     the chain. Otherwise, set it NULL. */
; 1185 : 
; 1186 :     if (*prev >= OP_SBRA)

	mov	al, BYTE PTR [ecx]
	cmp	al, 96					; 00000060H
	mov	DWORD PTR _prev$[esp+244], ecx
	jb	SHORT $LN534@match

; 1187 :       {
; 1188 :       saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */

	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR [edx+4]
	mov	DWORD PTR _saved_eptr$[esp+244], edx

; 1189 :       eptrb = eptrb->epb_prev;              /* Backup to previous group */

	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR [edx]
	mov	DWORD PTR _eptrb$[esp+240], edx
	mov	edx, DWORD PTR _saved_eptr$[esp+244]
	jmp	SHORT $LN533@match
$LN534@match:

; 1190 :       }
; 1191 :     else saved_eptr = NULL;

	xor	edx, edx
$LN533@match:

; 1192 : 
; 1193 :     /* If we are at the end of an assertion group, stop matching and return
; 1194 :     MATCH_MATCH, but record the current high water mark for use by positive
; 1195 :     assertions. Do this also for the "once" (atomic) groups. */
; 1196 : 
; 1197 :     if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
; 1198 :         *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
; 1199 :         *prev == OP_ONCE)

	cmp	al, 87					; 00000057H
	je	$LN531@match
	cmp	al, 88					; 00000058H
	je	$LN531@match
	cmp	al, 89					; 00000059H
	je	$LN531@match
	cmp	al, 90					; 0000005aH
	je	$LN531@match
	cmp	al, 92					; 0000005cH
	je	$LN531@match

; 1204 :       }
; 1205 : 
; 1206 :     /* For capturing groups we have to check the group number back at the start
; 1207 :     and if necessary complete handling an extraction by setting the offsets and
; 1208 :     bumping the high water mark. Note that whole-pattern recursion is coded as
; 1209 :     a recurse into group 0, so it won't be picked up here. Instead, we catch it
; 1210 :     when the OP_END is reached. Other recursion is handled here. */
; 1211 : 
; 1212 :     if (*prev == OP_CBRA || *prev == OP_SCBRA)

	cmp	al, 94					; 0000005eH
	je	SHORT $LN529@match
	cmp	al, 97					; 00000061H
	jne	$LN1311@match
$LN529@match:

; 1213 :       {
; 1214 :       number = GET2(prev, 1+LINK_SIZE);

	xor	eax, eax
	mov	ah, BYTE PTR [ecx+3]
	mov	al, BYTE PTR [ecx+4]
	mov	ecx, eax

; 1215 :       offset = number << 1;

	lea	eax, DWORD PTR [ecx+ecx]

; 1216 : 
; 1217 : #ifdef DEBUG
; 1218 :       printf("end bracket %d", number);
; 1219 :       printf("\n");
; 1220 : #endif
; 1221 : 
; 1222 :       md->capture_last = number;
; 1223 :       if (offset >= md->offset_max) md->offset_overflow = TRUE; else

	cmp	eax, DWORD PTR [ebp+20]
	mov	DWORD PTR _number$[esp+244], ecx
	mov	DWORD PTR [ebp+104], ecx
	jl	SHORT $LN528@match
	mov	DWORD PTR [ebp+44], 1
	jmp	SHORT $LN526@match
$LN528@match:

; 1224 :         {
; 1225 :         md->offset_vector[offset] =
; 1226 :           md->offset_vector[md->offset_end - number];

	mov	ebx, DWORD PTR [ebp+16]
	mov	ecx, DWORD PTR [ebp+12]
	sub	ebx, DWORD PTR _number$[esp+244]
	mov	ebx, DWORD PTR [ecx+ebx*4]
	mov	DWORD PTR [ecx+eax*4], ebx

; 1227 :         md->offset_vector[offset+1] = eptr - md->start_subject;

	mov	ebx, DWORD PTR [ebp+12]
	mov	ecx, esi
	sub	ecx, DWORD PTR [ebp+84]

; 1228 :         if (offset_top <= offset) offset_top = offset + 2;

	cmp	DWORD PTR _offset_top$[esp+240], eax
	mov	DWORD PTR [ebx+eax*4+4], ecx
	mov	ecx, DWORD PTR _number$[esp+244]
	jg	SHORT $LN526@match
	add	eax, 2
	mov	DWORD PTR _offset_top$[esp+240], eax
$LN526@match:

; 1229 :         }
; 1230 : 
; 1231 :       /* Handle a recursively called group. Restore the offsets
; 1232 :       appropriately and continue from after the call. */
; 1233 : 
; 1234 :       if (md->recursive != NULL && md->recursive->group_num == number)

	mov	ebx, DWORD PTR [ebp+120]
	test	ebx, ebx
	je	SHORT $LN1305@match
	cmp	DWORD PTR [ebx+4], ecx
	jne	SHORT $LN1305@match

; 1235 :         {
; 1236 :         recursion_info *rec = md->recursive;
; 1237 :         DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
; 1238 :         md->recursive = rec->prevrec;

	mov	edx, DWORD PTR [ebx]
	mov	DWORD PTR [ebp+120], edx

; 1239 :         mstart = rec->save_start;
; 1240 :         memcpy(md->offset_vector, rec->offset_save,
; 1241 :           rec->saved_max * sizeof(int));

	mov	ecx, DWORD PTR [ebx+20]
	mov	eax, DWORD PTR [ebx+12]
	mov	edx, DWORD PTR [ebx+16]
	add	ecx, ecx
	add	ecx, ecx
	push	ecx
	mov	DWORD PTR _mstart$[esp+244], eax
	mov	eax, DWORD PTR [ebp+12]
	push	edx
	push	eax
	call	_memcpy

; 1242 :         ecode = rec->after_call;
; 1243 :         ims = original_ims;

	mov	ecx, DWORD PTR _original_ims$[esp+256]
	mov	edi, DWORD PTR [ebx+8]
	add	esp, 12					; 0000000cH
	mov	DWORD PTR _ims$[esp+240], ecx

; 1244 :         break;

	jmp	$LL650@match
$LN1305@match:
	mov	ebx, DWORD PTR _mstart$[esp+240]
	mov	ecx, DWORD PTR _prev$[esp+244]
$LN1311@match:

; 1245 :         }
; 1246 :       }
; 1247 : 
; 1248 :     /* For both capturing and non-capturing groups, reset the value of the ims
; 1249 :     flags, in case they got changed during the group. */
; 1250 : 
; 1251 :     ims = original_ims;
; 1252 :     DPRINTF(("ims reset to %02lx\n", ims));
; 1253 : 
; 1254 :     /* For a non-repeating ket, just continue at this level. This also
; 1255 :     happens for a repeating ket if no characters were matched in the group.
; 1256 :     This is the forcible breaking of infinite loops as implemented in Perl
; 1257 :     5.005. If there is an options reset, it will get obeyed in the normal
; 1258 :     course of events. */
; 1259 : 
; 1260 :     if (*ecode == OP_KET || eptr == saved_eptr)

	cmp	BYTE PTR [edi], 84			; 00000054H
	mov	eax, DWORD PTR _original_ims$[esp+244]
	mov	DWORD PTR _ims$[esp+240], eax
	je	SHORT $LN523@match
	cmp	esi, edx
	jne	$LN524@match
$LN523@match:

; 1261 :       {
; 1262 :       ecode += 1 + LINK_SIZE;

	add	edi, 3

; 1263 :       break;

	jmp	$LL650@match
$LN519@match:

; 1291 :       goto TAIL_RECURSE;
; 1292 :       }
; 1293 :     /* Control never gets here */
; 1294 : 
; 1295 :     /* Start of subject unless notbol, or after internal newline if multiline */
; 1296 : 
; 1297 :     case OP_CIRC:
; 1298 :     if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);

	cmp	DWORD PTR [ebp+48], 0
	je	SHORT $LN516@match
	cmp	esi, DWORD PTR [ebp+84]
	je	$LN645@match
$LN516@match:

; 1299 :     if ((ims & PCRE_MULTILINE) != 0)

	test	BYTE PTR _ims$[esp+240], 2
	je	SHORT $LN515@match

; 1300 :       {
; 1301 :       if (eptr != md->start_subject &&
; 1302 :           (eptr == md->end_subject || !WAS_NEWLINE(eptr)))

	mov	eax, DWORD PTR [ebp+84]
	cmp	esi, eax
	je	SHORT $LN1338@match
	cmp	esi, DWORD PTR [ebp+88]
	je	$LN645@match
	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN672@match
	cmp	esi, eax
	jbe	$LN645@match
	push	0
	lea	edx, DWORD PTR [ebp+28]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_was_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	je	$LN645@match

; 1303 :         RRETURN(MATCH_NOMATCH);
; 1304 :       ecode++;

	add	edi, 1

; 1305 :       break;

	jmp	$LL650@match
$LN672@match:

; 1300 :       {
; 1301 :       if (eptr != md->start_subject &&
; 1302 :           (eptr == md->end_subject || !WAS_NEWLINE(eptr)))

	mov	ecx, DWORD PTR [ebp+28]
	add	eax, ecx
	cmp	esi, eax
	jb	$LN645@match
	mov	eax, esi
	sub	eax, ecx
	mov	dl, BYTE PTR [eax]
	cmp	dl, BYTE PTR [ebp+32]
	jne	$LN645@match
	cmp	ecx, 1
	je	SHORT $LN1338@match
	mov	al, BYTE PTR [eax+1]
	cmp	al, BYTE PTR [ebp+33]
	jne	$LN645@match
$LN1338@match:

; 1303 :         RRETURN(MATCH_NOMATCH);
; 1304 :       ecode++;

	add	edi, 1

; 1305 :       break;

	jmp	$LL650@match
$LN515@match:

; 1306 :       }
; 1307 :     /* ... else fall through */
; 1308 : 
; 1309 :     /* Start of subject assertion */
; 1310 : 
; 1311 :     case OP_SOD:
; 1312 :     if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+84]
	jne	$LN645@match

; 1313 :     ecode++;

	add	edi, 1

; 1314 :     break;

	jmp	$LL650@match
$LN510@match:

; 1315 : 
; 1316 :     /* Start of match assertion */
; 1317 : 
; 1318 :     case OP_SOM:
; 1319 :     if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+108]
	add	ecx, DWORD PTR [ebp+84]
	cmp	esi, ecx
	jne	$LN645@match

; 1320 :     ecode++;

	add	edi, 1

; 1321 :     break;

	jmp	$LL650@match
$LN508@match:

; 1322 : 
; 1323 :     /* Reset the start of match point */
; 1324 : 
; 1325 :     case OP_SET_SOM:
; 1326 :     mstart = eptr;

	mov	DWORD PTR _mstart$[esp+240], esi

; 1327 :     ecode++;

	add	edi, 1

; 1328 :     break;

	jmp	$LL650@match
$LN507@match:

; 1329 : 
; 1330 :     /* Assert before internal newline if multiline, or before a terminating
; 1331 :     newline unless endonly is set, else end of subject unless noteol is set. */
; 1332 : 
; 1333 :     case OP_DOLL:
; 1334 :     if ((ims & PCRE_MULTILINE) != 0)

	test	BYTE PTR _ims$[esp+240], 2
	je	SHORT $LN506@match

; 1335 :       {
; 1336 :       if (eptr < md->end_subject)

	mov	eax, DWORD PTR [ebp+88]
	cmp	esi, eax
	jae	SHORT $LN505@match

; 1337 :         { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }

	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN679@match
	push	0
	lea	edx, DWORD PTR [ebp+28]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	je	$LN645@match

; 1340 :       ecode++;

	add	edi, 1

; 1341 :       break;

	jmp	$LL650@match
$LN679@match:

; 1337 :         { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }

	mov	ecx, DWORD PTR [ebp+28]
	sub	eax, ecx
	cmp	esi, eax
	ja	$LN645@match
	mov	al, BYTE PTR [esi]
	cmp	al, BYTE PTR [ebp+32]
	jne	$LN645@match
	cmp	ecx, 1
	je	SHORT $LN1339@match
	mov	cl, BYTE PTR [esi+1]
	cmp	cl, BYTE PTR [ebp+33]

; 1338 :       else

	jmp	SHORT $LN1430@match
$LN505@match:

; 1339 :         { if (md->noteol) RRETURN(MATCH_NOMATCH); }

	cmp	DWORD PTR [ebp+52], 0
$LN1430@match:
	jne	$LN645@match
$LN1339@match:

; 1340 :       ecode++;

	add	edi, 1

; 1341 :       break;

	jmp	$LL650@match
$LN506@match:

; 1342 :       }
; 1343 :     else
; 1344 :       {
; 1345 :       if (md->noteol) RRETURN(MATCH_NOMATCH);

	cmp	DWORD PTR [ebp+52], 0
	jne	$LN645@match

; 1346 :       if (!md->endonly)

	cmp	DWORD PTR [ebp+60], 0
	jne	SHORT $LN499@match
$LN494@match:

; 1347 :         {
; 1348 :         if (eptr != md->end_subject &&
; 1349 :             (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))

	mov	eax, DWORD PTR [ebp+88]
	cmp	esi, eax
	je	SHORT $LN498@match
	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN686@match
	cmp	esi, eax
	jae	$LN645@match
	push	0
	lea	ebx, DWORD PTR [ebp+28]
	push	ebx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	je	$LN645@match
	jmp	SHORT $LN683@match
$LN686@match:
	mov	ecx, DWORD PTR [ebp+28]
	lea	ebx, DWORD PTR [ebp+28]
	sub	eax, ecx
	cmp	esi, eax
	ja	$LN645@match
	mov	dl, BYTE PTR [esi]
	cmp	dl, BYTE PTR [ebp+32]
	jne	$LN645@match
	cmp	ecx, 1
	je	SHORT $LN683@match
	mov	al, BYTE PTR [esi+1]
	cmp	al, BYTE PTR [ebp+33]
	jne	$LN645@match
$LN683@match:
	mov	ecx, DWORD PTR [ebp+88]
	sub	ecx, DWORD PTR [ebx]
	cmp	esi, ecx
	jne	$LN645@match
$LN498@match:

; 1350 :           RRETURN(MATCH_NOMATCH);
; 1351 :         ecode++;

	add	edi, 1

; 1352 :         break;

	jmp	$LL650@match
$LN499@match:

; 1353 :         }
; 1354 :       }
; 1355 :     /* ... else fall through for endonly */
; 1356 : 
; 1357 :     /* End of subject assertion (\z) */
; 1358 : 
; 1359 :     case OP_EOD:
; 1360 :     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jb	$LN645@match

; 1361 :     ecode++;

	add	edi, 1

; 1362 :     break;

	jmp	$LL650@match
$LN491@match:

; 1363 : 
; 1364 :     /* End of subject or ending \n assertion (\Z) */
; 1365 : 
; 1366 :     case OP_EODN:
; 1367 :     if (eptr != md->end_subject &&
; 1368 :         (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
; 1369 :       RRETURN(MATCH_NOMATCH);
; 1370 :     ecode++;
; 1371 :     break;
; 1372 : 
; 1373 :     /* Word boundary assertions */
; 1374 : 
; 1375 :     case OP_NOT_WORD_BOUNDARY:
; 1376 :     case OP_WORD_BOUNDARY:
; 1377 :       {
; 1378 : 
; 1379 :       /* Find out if the previous and current characters are "word" characters.
; 1380 :       It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
; 1381 :       be "non-word" characters. */
; 1382 : 
; 1383 : #ifdef SUPPORT_UTF8
; 1384 :       if (utf8)
; 1385 :         {
; 1386 :         if (eptr == md->start_subject) prev_is_word = FALSE; else
; 1387 :           {
; 1388 :           const uschar *lastptr = eptr - 1;
; 1389 :           while((*lastptr & 0xc0) == 0x80) lastptr--;
; 1390 :           GETCHAR(c, lastptr);
; 1391 :           prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
; 1392 :           }
; 1393 :         if (eptr >= md->end_subject) cur_is_word = FALSE; else
; 1394 :           {
; 1395 :           GETCHAR(c, eptr);
; 1396 :           cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
; 1397 :           }
; 1398 :         }
; 1399 :       else
; 1400 : #endif
; 1401 : 
; 1402 :       /* More streamlined when not in UTF-8 mode */
; 1403 : 
; 1404 :         {
; 1405 :         prev_is_word = (eptr != md->start_subject) &&
; 1406 :           ((md->ctypes[eptr[-1]] & ctype_word) != 0);

	cmp	esi, DWORD PTR [ebp+84]
	je	SHORT $LN695@match
	movzx	edx, BYTE PTR [esi-1]
	mov	eax, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+eax], 16			; 00000010H
	je	SHORT $LN695@match
	mov	ecx, 1
	jmp	SHORT $LN696@match
$LN695@match:
	xor	ecx, ecx
$LN696@match:

; 1407 :         cur_is_word = (eptr < md->end_subject) &&
; 1408 :           ((md->ctypes[*eptr] & ctype_word) != 0);

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN697@match
	movzx	edx, BYTE PTR [esi]
	mov	eax, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+eax], 16			; 00000010H
	je	SHORT $LN697@match
	mov	eax, 1
	jmp	SHORT $LN698@match
$LN697@match:
	xor	eax, eax
$LN698@match:

; 1409 :         }
; 1410 : 
; 1411 :       /* Now see if the situation is what we want */
; 1412 : 
; 1413 :       if ((*ecode++ == OP_WORD_BOUNDARY)?
; 1414 :            cur_is_word == prev_is_word : cur_is_word != prev_is_word)

	mov	dl, BYTE PTR [edi]
	add	edi, 1
	cmp	dl, 5
	jne	SHORT $LN699@match
	xor	edx, edx
	cmp	eax, ecx
	sete	dl
	jmp	SHORT $LN1419@match
$LN699@match:
	xor	edx, edx
	cmp	eax, ecx
	setne	dl
$LN1419@match:
	mov	eax, edx
	test	eax, eax
	je	$LL650@match
	pop	edi
	pop	esi
	pop	ebp
	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN489@match:

; 1415 :         RRETURN(MATCH_NOMATCH);
; 1416 :       }
; 1417 :     break;
; 1418 : 
; 1419 :     /* Match a single character type; inline for speed */
; 1420 : 
; 1421 :     case OP_ANY:
; 1422 :     if ((ims & PCRE_DOTALL) == 0)

	test	BYTE PTR _ims$[esp+240], 4
	jne	SHORT $LN1340@match

; 1423 :       {
; 1424 :       if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN706@match
	mov	eax, DWORD PTR [ebp+88]
	cmp	esi, eax
	jae	SHORT $LN1340@match
	push	0
	lea	edx, DWORD PTR [ebp+28]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	$LN645@match
	jmp	SHORT $LN1340@match
$LN706@match:
	mov	eax, DWORD PTR [ebp+28]
	mov	ecx, DWORD PTR [ebp+88]
	sub	ecx, eax
	cmp	esi, ecx
	ja	SHORT $LN1340@match
	mov	dl, BYTE PTR [esi]
	cmp	dl, BYTE PTR [ebp+32]
	jne	SHORT $LN1340@match
	cmp	eax, 1
	je	$LN645@match
	mov	al, BYTE PTR [esi+1]
	cmp	al, BYTE PTR [ebp+33]
	je	$LN645@match
$LN1340@match:

; 1425 :       }
; 1426 :     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);

	mov	ecx, esi
	add	esi, 1
	cmp	ecx, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1427 :     if (utf8)
; 1428 :       while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
; 1429 :     ecode++;

	add	edi, 1

; 1430 :     break;

	jmp	$LL650@match
$LN482@match:

; 1431 : 
; 1432 :     /* Match a single byte, even in UTF-8 mode. This opcode really does match
; 1433 :     any byte, even newline, independent of the setting of PCRE_DOTALL. */
; 1434 : 
; 1435 :     case OP_ANYBYTE:
; 1436 :     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);

	mov	edx, esi
	add	esi, 1
	cmp	edx, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1437 :     ecode++;

	add	edi, 1

; 1438 :     break;

	jmp	$LL650@match
$LN480@match:

; 1439 : 
; 1440 :     case OP_NOT_DIGIT:
; 1441 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1442 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]

; 1443 :     if (
; 1444 : #ifdef SUPPORT_UTF8
; 1445 :        c < 256 &&
; 1446 : #endif
; 1447 :        (md->ctypes[c] & ctype_digit) != 0
; 1448 :        )

	mov	ecx, DWORD PTR [ebp+40]
	add	esi, 1
	test	BYTE PTR [eax+ecx], 4
	jne	$LN645@match

; 1449 :       RRETURN(MATCH_NOMATCH);
; 1450 :     ecode++;

	add	edi, 1

; 1451 :     break;

	jmp	$LL650@match
$LN477@match:

; 1452 : 
; 1453 :     case OP_DIGIT:
; 1454 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1455 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]

; 1456 :     if (
; 1457 : #ifdef SUPPORT_UTF8
; 1458 :        c >= 256 ||
; 1459 : #endif
; 1460 :        (md->ctypes[c] & ctype_digit) == 0
; 1461 :        )

	mov	edx, DWORD PTR [ebp+40]
	add	esi, 1
	test	BYTE PTR [eax+edx], 4
	je	$LN645@match

; 1462 :       RRETURN(MATCH_NOMATCH);
; 1463 :     ecode++;

	add	edi, 1

; 1464 :     break;

	jmp	$LL650@match
$LN474@match:

; 1465 : 
; 1466 :     case OP_NOT_WHITESPACE:
; 1467 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1468 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]

; 1469 :     if (
; 1470 : #ifdef SUPPORT_UTF8
; 1471 :        c < 256 &&
; 1472 : #endif
; 1473 :        (md->ctypes[c] & ctype_space) != 0
; 1474 :        )

	mov	ecx, DWORD PTR [ebp+40]
	add	esi, 1
	test	BYTE PTR [eax+ecx], 1
	jne	$LN645@match

; 1475 :       RRETURN(MATCH_NOMATCH);
; 1476 :     ecode++;

	add	edi, 1

; 1477 :     break;

	jmp	$LL650@match
$LN471@match:

; 1478 : 
; 1479 :     case OP_WHITESPACE:
; 1480 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1481 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]

; 1482 :     if (
; 1483 : #ifdef SUPPORT_UTF8
; 1484 :        c >= 256 ||
; 1485 : #endif
; 1486 :        (md->ctypes[c] & ctype_space) == 0
; 1487 :        )

	mov	edx, DWORD PTR [ebp+40]
	add	esi, 1
	test	BYTE PTR [eax+edx], 1
	je	$LN645@match

; 1488 :       RRETURN(MATCH_NOMATCH);
; 1489 :     ecode++;

	add	edi, 1

; 1490 :     break;

	jmp	$LL650@match
$LN468@match:

; 1491 : 
; 1492 :     case OP_NOT_WORDCHAR:
; 1493 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1494 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]

; 1495 :     if (
; 1496 : #ifdef SUPPORT_UTF8
; 1497 :        c < 256 &&
; 1498 : #endif
; 1499 :        (md->ctypes[c] & ctype_word) != 0
; 1500 :        )

	mov	ecx, DWORD PTR [ebp+40]
	add	esi, 1
	test	BYTE PTR [eax+ecx], 16			; 00000010H
	jne	$LN645@match

; 1501 :       RRETURN(MATCH_NOMATCH);
; 1502 :     ecode++;

	add	edi, 1

; 1503 :     break;

	jmp	$LL650@match
$LN465@match:

; 1504 : 
; 1505 :     case OP_WORDCHAR:
; 1506 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1507 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]

; 1508 :     if (
; 1509 : #ifdef SUPPORT_UTF8
; 1510 :        c >= 256 ||
; 1511 : #endif
; 1512 :        (md->ctypes[c] & ctype_word) == 0
; 1513 :        )

	mov	edx, DWORD PTR [ebp+40]
	add	esi, 1
	test	BYTE PTR [eax+edx], 16			; 00000010H
	je	$LN645@match

; 1514 :       RRETURN(MATCH_NOMATCH);
; 1515 :     ecode++;

	add	edi, 1

; 1516 :     break;

	jmp	$LL650@match
$LN462@match:

; 1517 : 
; 1518 :     case OP_ANYNL:
; 1519 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+88]
	cmp	esi, ecx
	jae	$LN645@match

; 1520 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]
	add	esi, 1

; 1521 :     switch(c)

	cmp	eax, 13					; 0000000dH
	ja	SHORT $LN708@match
	je	SHORT $LN457@match
	cmp	eax, 10					; 0000000aH
	je	SHORT $LN453@match
	jbe	$LN645@match
	cmp	eax, 12					; 0000000cH
	jmp	SHORT $LN1420@match
$LN457@match:

; 1522 :       {
; 1523 :       default: RRETURN(MATCH_NOMATCH);
; 1524 :       case 0x000d:
; 1525 :       if (eptr < md->end_subject && *eptr == 0x0a) eptr++;

	cmp	esi, ecx
	jae	SHORT $LN453@match
	cmp	BYTE PTR [esi], 10			; 0000000aH
	jne	SHORT $LN453@match
	add	esi, 1

; 1537 :       break;
; 1538 :       }
; 1539 :     ecode++;

	add	edi, 1

; 1540 :     break;

	jmp	$LL650@match
$LN708@match:

; 1521 :     switch(c)

	cmp	eax, 133				; 00000085H
	je	SHORT $LN454@match
	cmp	eax, 8231				; 00002027H
	jbe	$LN645@match
	cmp	eax, 8233				; 00002029H
$LN1420@match:
	ja	$LN645@match
$LN454@match:

; 1526 :       break;
; 1527 : 
; 1528 :       case 0x000a:
; 1529 :       break;
; 1530 : 
; 1531 :       case 0x000b:
; 1532 :       case 0x000c:
; 1533 :       case 0x0085:
; 1534 :       case 0x2028:
; 1535 :       case 0x2029:
; 1536 :       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);

	cmp	DWORD PTR [ebp+76], 0
	jne	$LN645@match
$LN453@match:

; 1537 :       break;
; 1538 :       }
; 1539 :     ecode++;

	add	edi, 1

; 1540 :     break;

	jmp	$LL650@match
$LN452@match:

; 1541 : 
; 1542 :     case OP_NOT_HSPACE:
; 1543 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1544 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]
	add	esi, 1

; 1545 :     switch(c)

	cmp	eax, 6158				; 0000180eH
	ja	SHORT $LN709@match
	je	$LN645@match
	cmp	eax, 160				; 000000a0H
	ja	SHORT $LN710@match
	je	$LN645@match
	cmp	eax, 9
	je	$LN645@match
	cmp	eax, 32					; 00000020H
	jmp	SHORT $LN1421@match
$LN710@match:
	cmp	eax, 5760				; 00001680H
	jmp	SHORT $LN1421@match
$LN709@match:
	cmp	eax, 8287				; 0000205fH
	ja	SHORT $LN711@match
	je	$LN645@match
	cmp	eax, 8192				; 00002000H
	jb	SHORT $LN448@match
	cmp	eax, 8202				; 0000200aH
	jbe	$LN645@match
	cmp	eax, 8239				; 0000202fH
	jmp	SHORT $LN1421@match
$LN711@match:
	cmp	eax, 12288				; 00003000H
$LN1421@match:
	je	$LN645@match
$LN448@match:

; 1546 :       {
; 1547 :       default: break;
; 1548 :       case 0x09:      /* HT */
; 1549 :       case 0x20:      /* SPACE */
; 1550 :       case 0xa0:      /* NBSP */
; 1551 :       case 0x1680:    /* OGHAM SPACE MARK */
; 1552 :       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 1553 :       case 0x2000:    /* EN QUAD */
; 1554 :       case 0x2001:    /* EM QUAD */
; 1555 :       case 0x2002:    /* EN SPACE */
; 1556 :       case 0x2003:    /* EM SPACE */
; 1557 :       case 0x2004:    /* THREE-PER-EM SPACE */
; 1558 :       case 0x2005:    /* FOUR-PER-EM SPACE */
; 1559 :       case 0x2006:    /* SIX-PER-EM SPACE */
; 1560 :       case 0x2007:    /* FIGURE SPACE */
; 1561 :       case 0x2008:    /* PUNCTUATION SPACE */
; 1562 :       case 0x2009:    /* THIN SPACE */
; 1563 :       case 0x200A:    /* HAIR SPACE */
; 1564 :       case 0x202f:    /* NARROW NO-BREAK SPACE */
; 1565 :       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 1566 :       case 0x3000:    /* IDEOGRAPHIC SPACE */
; 1567 :       RRETURN(MATCH_NOMATCH);
; 1568 :       }
; 1569 :     ecode++;

	add	edi, 1

; 1570 :     break;

	jmp	$LL650@match
$LN446@match:

; 1571 : 
; 1572 :     case OP_HSPACE:
; 1573 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1574 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]
	add	esi, 1

; 1575 :     switch(c)

	cmp	eax, 6158				; 0000180eH
	ja	SHORT $LN712@match
	je	SHORT $LN441@match
	cmp	eax, 160				; 000000a0H
	ja	SHORT $LN713@match
	je	SHORT $LN441@match
	cmp	eax, 9
	je	SHORT $LN441@match
	cmp	eax, 32					; 00000020H
	jmp	SHORT $LN1422@match
$LN713@match:
	cmp	eax, 5760				; 00001680H
	jmp	SHORT $LN1422@match
$LN712@match:
	cmp	eax, 8287				; 0000205fH
	ja	SHORT $LN714@match
	je	SHORT $LN441@match
	cmp	eax, 8192				; 00002000H
	jb	$LN645@match
	cmp	eax, 8202				; 0000200aH
	jbe	SHORT $LN441@match
	cmp	eax, 8239				; 0000202fH
	jmp	SHORT $LN1422@match
$LN714@match:
	cmp	eax, 12288				; 00003000H
$LN1422@match:
	jne	$LN645@match
$LN441@match:

; 1576 :       {
; 1577 :       default: RRETURN(MATCH_NOMATCH);
; 1578 :       case 0x09:      /* HT */
; 1579 :       case 0x20:      /* SPACE */
; 1580 :       case 0xa0:      /* NBSP */
; 1581 :       case 0x1680:    /* OGHAM SPACE MARK */
; 1582 :       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 1583 :       case 0x2000:    /* EN QUAD */
; 1584 :       case 0x2001:    /* EM QUAD */
; 1585 :       case 0x2002:    /* EN SPACE */
; 1586 :       case 0x2003:    /* EM SPACE */
; 1587 :       case 0x2004:    /* THREE-PER-EM SPACE */
; 1588 :       case 0x2005:    /* FOUR-PER-EM SPACE */
; 1589 :       case 0x2006:    /* SIX-PER-EM SPACE */
; 1590 :       case 0x2007:    /* FIGURE SPACE */
; 1591 :       case 0x2008:    /* PUNCTUATION SPACE */
; 1592 :       case 0x2009:    /* THIN SPACE */
; 1593 :       case 0x200A:    /* HAIR SPACE */
; 1594 :       case 0x202f:    /* NARROW NO-BREAK SPACE */
; 1595 :       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 1596 :       case 0x3000:    /* IDEOGRAPHIC SPACE */
; 1597 :       break;
; 1598 :       }
; 1599 :     ecode++;

	add	edi, 1

; 1600 :     break;

	jmp	$LL650@match
$LN440@match:

; 1601 : 
; 1602 :     case OP_NOT_VSPACE:
; 1603 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1604 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]
	add	esi, 1

; 1605 :     switch(c)

	cmp	eax, 133				; 00000085H
	ja	SHORT $LN715@match
	je	$LN645@match
	cmp	eax, 10					; 0000000aH
	jb	SHORT $LN436@match
	cmp	eax, 13					; 0000000dH
	jmp	SHORT $LN1423@match
$LN715@match:
	cmp	eax, 8232				; 00002028H
	jb	SHORT $LN436@match
	cmp	eax, 8233				; 00002029H
$LN1423@match:
	jbe	$LN645@match
$LN436@match:

; 1606 :       {
; 1607 :       default: break;
; 1608 :       case 0x0a:      /* LF */
; 1609 :       case 0x0b:      /* VT */
; 1610 :       case 0x0c:      /* FF */
; 1611 :       case 0x0d:      /* CR */
; 1612 :       case 0x85:      /* NEL */
; 1613 :       case 0x2028:    /* LINE SEPARATOR */
; 1614 :       case 0x2029:    /* PARAGRAPH SEPARATOR */
; 1615 :       RRETURN(MATCH_NOMATCH);
; 1616 :       }
; 1617 :     ecode++;

	add	edi, 1

; 1618 :     break;

	jmp	$LL650@match
$LN434@match:

; 1619 : 
; 1620 :     case OP_VSPACE:
; 1621 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1622 :     GETCHARINCTEST(c, eptr);

	movzx	eax, BYTE PTR [esi]
	add	esi, 1

; 1623 :     switch(c)

	cmp	eax, 133				; 00000085H
	ja	SHORT $LN716@match
	je	SHORT $LN429@match
	cmp	eax, 10					; 0000000aH
	jb	$LN645@match
	cmp	eax, 13					; 0000000dH
	jmp	SHORT $LN1424@match
$LN716@match:
	cmp	eax, 8232				; 00002028H
	jb	$LN645@match
	cmp	eax, 8233				; 00002029H
$LN1424@match:
	ja	$LN645@match
$LN429@match:

; 1624 :       {
; 1625 :       default: RRETURN(MATCH_NOMATCH);
; 1626 :       case 0x0a:      /* LF */
; 1627 :       case 0x0b:      /* VT */
; 1628 :       case 0x0c:      /* FF */
; 1629 :       case 0x0d:      /* CR */
; 1630 :       case 0x85:      /* NEL */
; 1631 :       case 0x2028:    /* LINE SEPARATOR */
; 1632 :       case 0x2029:    /* PARAGRAPH SEPARATOR */
; 1633 :       break;
; 1634 :       }
; 1635 :     ecode++;

	add	edi, 1

; 1636 :     break;

	jmp	$LL650@match
$LN428@match:

; 1637 : 
; 1638 : #ifdef SUPPORT_UCP
; 1639 :     /* Check the next character by Unicode property. We will get here only
; 1640 :     if the support is in the binary; otherwise a compile-time error occurs. */
; 1641 : 
; 1642 :     case OP_PROP:
; 1643 :     case OP_NOTPROP:
; 1644 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 1645 :     GETCHARINCTEST(c, eptr);
; 1646 :       {
; 1647 :       int chartype, script;
; 1648 :       int category = _pcre_ucp_findprop(c, &chartype, &script);
; 1649 : 
; 1650 :       switch(ecode[1])
; 1651 :         {
; 1652 :         case PT_ANY:
; 1653 :         if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
; 1654 :         break;
; 1655 : 
; 1656 :         case PT_LAMP:
; 1657 :         if ((chartype == ucp_Lu ||
; 1658 :              chartype == ucp_Ll ||
; 1659 :              chartype == ucp_Lt) == (op == OP_NOTPROP))
; 1660 :           RRETURN(MATCH_NOMATCH);
; 1661 :          break;
; 1662 : 
; 1663 :         case PT_GC:
; 1664 :         if ((ecode[2] != category) == (op == OP_PROP))
; 1665 :           RRETURN(MATCH_NOMATCH);
; 1666 :         break;
; 1667 : 
; 1668 :         case PT_PC:
; 1669 :         if ((ecode[2] != chartype) == (op == OP_PROP))
; 1670 :           RRETURN(MATCH_NOMATCH);
; 1671 :         break;
; 1672 : 
; 1673 :         case PT_SC:
; 1674 :         if ((ecode[2] != script) == (op == OP_PROP))
; 1675 :           RRETURN(MATCH_NOMATCH);
; 1676 :         break;
; 1677 : 
; 1678 :         default:
; 1679 :         RRETURN(PCRE_ERROR_INTERNAL);
; 1680 :         }
; 1681 : 
; 1682 :       ecode += 3;
; 1683 :       }
; 1684 :     break;
; 1685 : 
; 1686 :     /* Match an extended Unicode sequence. We will get here only if the support
; 1687 :     is in the binary; otherwise a compile-time error occurs. */
; 1688 : 
; 1689 :     case OP_EXTUNI:
; 1690 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 1691 :     GETCHARINCTEST(c, eptr);
; 1692 :       {
; 1693 :       int chartype, script;
; 1694 :       int category = _pcre_ucp_findprop(c, &chartype, &script);
; 1695 :       if (category == ucp_M) RRETURN(MATCH_NOMATCH);
; 1696 :       while (eptr < md->end_subject)
; 1697 :         {
; 1698 :         int len = 1;
; 1699 :         if (!utf8) c = *eptr; else
; 1700 :           {
; 1701 :           GETCHARLEN(c, eptr, len);
; 1702 :           }
; 1703 :         category = _pcre_ucp_findprop(c, &chartype, &script);
; 1704 :         if (category != ucp_M) break;
; 1705 :         eptr += len;
; 1706 :         }
; 1707 :       }
; 1708 :     ecode++;
; 1709 :     break;
; 1710 : #endif
; 1711 : 
; 1712 : 
; 1713 :     /* Match a back reference, possibly repeatedly. Look past the end of the
; 1714 :     item to see if there is repeat information following. The code is similar
; 1715 :     to that for character classes, but repeated for efficiency. Then obey
; 1716 :     similar code to character type repeats - written out again for speed.
; 1717 :     However, if the referenced string is the empty string, always treat
; 1718 :     it as matched, any number of times (otherwise there could be infinite
; 1719 :     loops). */
; 1720 : 
; 1721 :     case OP_REF:
; 1722 :       {
; 1723 :       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]

; 1724 :       ecode += 3;                                 /* Advance past item */

	add	edi, 3
	mov	al, BYTE PTR [edi-1]
	add	eax, eax

; 1725 : 
; 1726 :       /* If the reference is unset, set the length to be longer than the amount
; 1727 :       of subject left; this ensures that every attempt at a match fails. We
; 1728 :       can't just fail here, because of the possibility of quantifiers with zero
; 1729 :       minima. */
; 1730 : 
; 1731 :       length = (offset >= offset_top || md->offset_vector[offset] < 0)?
; 1732 :         md->end_subject - eptr + 1 :
; 1733 :         md->offset_vector[offset+1] - md->offset_vector[offset];

	cmp	eax, DWORD PTR _offset_top$[esp+240]
	mov	DWORD PTR _offset$[esp+244], eax
	jge	SHORT $LN717@match
	mov	ecx, DWORD PTR [ebp+12]
	lea	eax, DWORD PTR [ecx+eax*4]
	mov	ecx, DWORD PTR [eax]
	test	ecx, ecx
	jl	SHORT $LN717@match
	mov	ebx, DWORD PTR [eax+4]
	sub	ebx, ecx
	jmp	SHORT $LN718@match
$LN717@match:
	mov	ebx, DWORD PTR [ebp+88]
	sub	ebx, esi
	add	ebx, 1
$LN718@match:

; 1734 : 
; 1735 :       /* Set up for repetition, or handle the non-repeated case */
; 1736 : 
; 1737 :       switch (*ecode)

	mov	cl, BYTE PTR [edi]
	movzx	eax, cl
	lea	edx, DWORD PTR [eax-69]
	cmp	edx, 7
	ja	$LN421@match
	movzx	edx, BYTE PTR $LN1243@match[edx]
	jmp	DWORD PTR $LN1433@match[edx*4]
$LN425@match:

; 1738 :         {
; 1739 :         case OP_CRSTAR:
; 1740 :         case OP_CRMINSTAR:
; 1741 :         case OP_CRPLUS:
; 1742 :         case OP_CRMINPLUS:
; 1743 :         case OP_CRQUERY:
; 1744 :         case OP_CRMINQUERY:
; 1745 :         c = *ecode++ - OP_CRSTAR;

	add	eax, -69				; ffffffbbH

; 1746 :         minimize = (c & 1) != 0;

	mov	ecx, eax
	and	ecx, 1
	mov	DWORD PTR _minimize$[esp+244], ecx

; 1747 :         min = rep_min[c];                 /* Pick up values from tables; */

	movsx	ecx, BYTE PTR _rep_min[eax]

; 1748 :         max = rep_max[c];                 /* zero for max => infinity */

	movsx	eax, BYTE PTR _rep_max[eax]
	add	edi, 1

; 1749 :         if (max == 0) max = INT_MAX;

	test	eax, eax
	mov	DWORD PTR _min$[esp+244], ecx
	mov	DWORD PTR _max$[esp+244], eax
	jne	SHORT $LN426@match
	mov	DWORD PTR _max$[esp+244], 2147483647	; 7fffffffH

; 1750 :         break;

	jmp	SHORT $LN426@match
$LN423@match:

; 1751 : 
; 1752 :         case OP_CRRANGE:
; 1753 :         case OP_CRMINRANGE:
; 1754 :         minimize = (*ecode == OP_CRMINRANGE);

	xor	edx, edx
	cmp	cl, 76					; 0000004cH
	sete	dl

; 1755 :         min = GET2(ecode, 1);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	DWORD PTR _minimize$[esp+244], edx
	mov	al, BYTE PTR [edi+2]
	mov	DWORD PTR _min$[esp+244], eax

; 1756 :         max = GET2(ecode, 3);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+3]
	mov	al, BYTE PTR [edi+4]

; 1757 :         if (max == 0) max = INT_MAX;

	test	eax, eax
	mov	DWORD PTR _max$[esp+244], eax
	jne	SHORT $LN422@match
	mov	DWORD PTR _max$[esp+244], 2147483647	; 7fffffffH
$LN422@match:

; 1758 :         ecode += 5;

	add	edi, 5
$LN426@match:

; 1765 :         }
; 1766 : 
; 1767 :       /* If the length of the reference is zero, just continue with the
; 1768 :       main loop. */
; 1769 : 
; 1770 :       if (length == 0) continue;

	test	ebx, ebx
	je	$LL650@match

; 1771 : 
; 1772 :       /* First, ensure the minimum number of matches are present. We get back
; 1773 :       the length of the reference string explicitly rather than passing the
; 1774 :       address of eptr, so that eptr can be a register variable. */
; 1775 : 
; 1776 :       for (i = 1; i <= min; i++)

	mov	eax, DWORD PTR _min$[esp+244]
	cmp	eax, 1
	mov	DWORD PTR _i$[esp+244], 1
	jl	SHORT $LN416@match
$LL418@match:

; 1777 :         {
; 1778 :         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset$[esp+244]
	push	ecx
	push	esi
	mov	ecx, ebp
	mov	eax, ebx
	call	_match_ref
	add	esp, 8
	test	eax, eax
	je	$LN645@match
	mov	eax, DWORD PTR _i$[esp+244]
	add	eax, 1

; 1779 :         eptr += length;

	add	esi, ebx
	cmp	eax, DWORD PTR _min$[esp+244]
	mov	DWORD PTR _i$[esp+244], eax
	jle	SHORT $LL418@match

; 1771 : 
; 1772 :       /* First, ensure the minimum number of matches are present. We get back
; 1773 :       the length of the reference string explicitly rather than passing the
; 1774 :       address of eptr, so that eptr can be a register variable. */
; 1775 : 
; 1776 :       for (i = 1; i <= min; i++)

	mov	eax, DWORD PTR _min$[esp+244]
$LN416@match:

; 1780 :         }
; 1781 : 
; 1782 :       /* If min = max, continue at the same level without recursion.
; 1783 :       They are not both allowed to be zero. */
; 1784 : 
; 1785 :       if (min == max) continue;

	mov	ecx, DWORD PTR _max$[esp+244]
	cmp	eax, ecx
	je	$LL650@match

; 1786 : 
; 1787 :       /* If minimizing, keep trying and advancing the pointer */
; 1788 : 
; 1789 :       if (minimize)

	cmp	DWORD PTR _minimize$[esp+244], 0
	je	$LN413@match

; 1790 :         {
; 1791 :         for (fi = min;; fi++)

	mov	eax, DWORD PTR _min$[esp+244]

; 1792 :           {
; 1793 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);

	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	mov	DWORD PTR _i$[esp+244], eax
	mov	eax, DWORD PTR _rdepth$[esp+240]
	add	eax, 1
	push	eax
	push	0
	push	ecx
	mov	ecx, DWORD PTR _mstart$[esp+252]
	push	edx
	push	ebp
	mov	DWORD PTR tv3629[esp+264], eax
	mov	eax, DWORD PTR _offset_top$[esp+260]
	push	eax
	push	ecx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1794 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	npad	3
$LL412@match:

; 1795 :           if (fi >= max || !match_ref(offset, eptr, length, md, ims))

	mov	edx, DWORD PTR _max$[esp+244]
	cmp	DWORD PTR _i$[esp+244], edx
	jge	$LN645@match
	mov	eax, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset$[esp+244]
	push	eax
	push	esi
	mov	ecx, ebp
	mov	eax, ebx
	call	_match_ref
	add	esp, 8
	test	eax, eax
	je	$LN645@match
	mov	ecx, DWORD PTR tv3629[esp+244]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	edx
	mov	edx, DWORD PTR _mstart$[esp+252]
	push	eax
	push	ebp
	push	ecx
	push	edx

; 1796 :             RRETURN(MATCH_NOMATCH);
; 1797 :           eptr += length;

	add	esi, ebx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LL412@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN421@match:

; 1759 :         break;
; 1760 : 
; 1761 :         default:               /* No repeat follows */
; 1762 :         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);

	mov	edx, DWORD PTR _ims$[esp+240]
	push	edx
	mov	edx, DWORD PTR _offset$[esp+248]
	push	esi
	mov	ecx, ebp
	mov	eax, ebx
	call	_match_ref
	add	esp, 8
	test	eax, eax
	je	$LN645@match

; 1763 :         eptr += length;

	add	esi, ebx

; 1764 :         continue;              /* With the main loop */

	jmp	$LL650@match
$LN406@match:

; 1819 :         }
; 1820 :       }
; 1821 :     /* Control never gets here */
; 1822 : 
; 1823 : 
; 1824 : 
; 1825 :     /* Match a bit-mapped character class, possibly repeatedly. This op code is
; 1826 :     used when all the characters in the class have values in the range 0-255,
; 1827 :     and either the matching is caseful, or the characters are in the range
; 1828 :     0-127 when UTF-8 processing is enabled. The only difference between
; 1829 :     OP_CLASS and OP_NCLASS occurs when a data character outside the range is
; 1830 :     encountered.
; 1831 : 
; 1832 :     First, look past the end of the item to see if there is repeat information
; 1833 :     following. Then obey similar code to character type repeats - written out
; 1834 :     again for speed. */
; 1835 : 
; 1836 :     case OP_NCLASS:
; 1837 :     case OP_CLASS:
; 1838 :       {
; 1839 :       data = ecode + 1;                /* Save for matching */

	lea	eax, DWORD PTR [edi+1]

; 1840 :       ecode += 33;                     /* Advance past the item */

	add	edi, 33					; 00000021H
	mov	DWORD PTR _data$[esp+244], eax

; 1841 : 
; 1842 :       switch (*ecode)

	movzx	eax, BYTE PTR [edi]
	lea	ecx, DWORD PTR [eax-69]
	cmp	ecx, 7
	ja	$LN391@match
	movzx	ecx, BYTE PTR $LN1244@match[ecx]
	jmp	DWORD PTR $LN1434@match[ecx*4]
$LN395@match:

; 1843 :         {
; 1844 :         case OP_CRSTAR:
; 1845 :         case OP_CRMINSTAR:
; 1846 :         case OP_CRPLUS:
; 1847 :         case OP_CRMINPLUS:
; 1848 :         case OP_CRQUERY:
; 1849 :         case OP_CRMINQUERY:
; 1850 :         c = *ecode++ - OP_CRSTAR;
; 1851 :         minimize = (c & 1) != 0;
; 1852 :         min = rep_min[c];                 /* Pick up values from tables; */

	movsx	ecx, BYTE PTR _rep_min[eax-69]
	add	eax, -69				; ffffffbbH
	mov	edx, eax

; 1853 :         max = rep_max[c];                 /* zero for max => infinity */

	movsx	eax, BYTE PTR _rep_max[eax]
	and	edx, 1
	add	edi, 1

; 1854 :         if (max == 0) max = INT_MAX;

	test	eax, eax
	mov	DWORD PTR _minimize$[esp+244], edx
	mov	DWORD PTR _min$[esp+244], ecx
	mov	DWORD PTR _max$[esp+244], eax
	jne	SHORT $LN1328@match
	mov	eax, 2147483647				; 7fffffffH

; 1855 :         break;

	jmp	SHORT $LN1425@match
$LN393@match:

; 1856 : 
; 1857 :         case OP_CRRANGE:
; 1858 :         case OP_CRMINRANGE:
; 1859 :         minimize = (*ecode == OP_CRMINRANGE);

	xor	edx, edx
	cmp	BYTE PTR [edi], 76			; 0000004cH
	sete	dl

; 1860 :         min = GET2(ecode, 1);
; 1861 :         max = GET2(ecode, 3);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+3]
	xor	ecx, ecx
	mov	ch, BYTE PTR [edi+1]
	mov	DWORD PTR _minimize$[esp+244], edx
	mov	al, BYTE PTR [edi+4]
	mov	cl, BYTE PTR [edi+2]

; 1862 :         if (max == 0) max = INT_MAX;

	test	eax, eax
	mov	DWORD PTR _max$[esp+244], eax
	mov	DWORD PTR _min$[esp+244], ecx
	jne	SHORT $LN392@match
	mov	eax, 2147483647				; 7fffffffH
	mov	DWORD PTR _max$[esp+244], eax
$LN392@match:

; 1863 :         ecode += 5;

	add	edi, 5

; 1864 :         break;

	jmp	SHORT $LN1328@match
$LN391@match:

; 1865 : 
; 1866 :         default:               /* No repeat follows */
; 1867 :         min = max = 1;

	mov	eax, 1
	mov	ecx, eax
	mov	DWORD PTR _min$[esp+244], ecx
$LN1425@match:
	mov	DWORD PTR _max$[esp+244], eax
$LN1328@match:

; 1868 :         break;
; 1869 :         }
; 1870 : 
; 1871 :       /* First, ensure the minimum number of matches are present. */
; 1872 : 
; 1873 : #ifdef SUPPORT_UTF8
; 1874 :       /* UTF-8 mode */
; 1875 :       if (utf8)
; 1876 :         {
; 1877 :         for (i = 1; i <= min; i++)
; 1878 :           {
; 1879 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 1880 :           GETCHARINC(c, eptr);
; 1881 :           if (c > 255)
; 1882 :             {
; 1883 :             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
; 1884 :             }
; 1885 :           else
; 1886 :             {
; 1887 :             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
; 1888 :             }
; 1889 :           }
; 1890 :         }
; 1891 :       else
; 1892 : #endif
; 1893 :       /* Not UTF-8 mode */
; 1894 :         {
; 1895 :         for (i = 1; i <= min; i++)

	cmp	ecx, 1
	mov	DWORD PTR _i$[esp+244], 1
	jl	SHORT $LN388@match
	npad	8
$LL390@match:

; 1896 :           {
; 1897 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1898 :           c = *eptr++;

	movzx	eax, BYTE PTR [esi]

; 1899 :           if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);

	mov	ecx, eax
	and	ecx, 7
	mov	edx, 1
	shl	edx, cl
	mov	ecx, DWORD PTR _data$[esp+244]
	shr	eax, 3
	mov	al, BYTE PTR [eax+ecx]
	add	esi, 1
	test	dl, al
	je	$LN645@match
	mov	eax, DWORD PTR _i$[esp+244]
	mov	ecx, DWORD PTR _min$[esp+244]
	add	eax, 1
	cmp	eax, ecx
	mov	DWORD PTR _i$[esp+244], eax
	jle	SHORT $LL390@match
	mov	edx, DWORD PTR _minimize$[esp+244]
	mov	eax, DWORD PTR _max$[esp+244]
$LN388@match:

; 1900 :           }
; 1901 :         }
; 1902 : 
; 1903 :       /* If max == min we can continue with the main loop without the
; 1904 :       need to recurse. */
; 1905 : 
; 1906 :       if (min == max) continue;

	cmp	ecx, eax
	je	$LL650@match

; 1907 : 
; 1908 :       /* If minimizing, keep testing the rest of the expression and advancing
; 1909 :       the pointer while it matches the class. */
; 1910 : 
; 1911 :       if (minimize)

	test	edx, edx

; 1912 :         {
; 1913 : #ifdef SUPPORT_UTF8
; 1914 :         /* UTF-8 mode */
; 1915 :         if (utf8)
; 1916 :           {
; 1917 :           for (fi = min;; fi++)
; 1918 :             {
; 1919 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
; 1920 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 1921 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 1922 :             GETCHARINC(c, eptr);
; 1923 :             if (c > 255)
; 1924 :               {
; 1925 :               if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
; 1926 :               }
; 1927 :             else
; 1928 :               {
; 1929 :               if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
; 1930 :               }
; 1931 :             }
; 1932 :           }
; 1933 :         else
; 1934 : #endif
; 1935 :         /* Not UTF-8 mode */
; 1936 :           {
; 1937 :           for (fi = min;; fi++)

	mov	DWORD PTR _i$[esp+244], ecx
	je	$LN384@match

; 1938 :             {
; 1939 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);

	mov	eax, DWORD PTR _rdepth$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	add	eax, 1
	push	eax
	push	0
	push	ecx
	push	edx
	push	ebp
	mov	DWORD PTR tv3629[esp+264], eax
	mov	eax, DWORD PTR _offset_top$[esp+260]
	push	eax
	push	ebx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1940 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	npad	7
$LL383@match:

; 1941 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR _max$[esp+244]
	cmp	DWORD PTR _i$[esp+244], ecx
	jge	$LN645@match
	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 1942 :             c = *eptr++;

	movzx	eax, BYTE PTR [esi]

; 1943 :             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);

	mov	ecx, eax
	and	ecx, 7
	mov	edx, 1
	shl	edx, cl
	mov	ecx, DWORD PTR _data$[esp+244]
	shr	eax, 3
	mov	al, BYTE PTR [eax+ecx]
	add	esi, 1
	test	dl, al
	je	$LN645@match
	mov	ecx, DWORD PTR tv3629[esp+244]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	edx
	push	eax
	push	ebp
	push	ecx
	push	ebx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LL383@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN376@match:

; 2002 :         }
; 2003 :       }
; 2004 :     /* Control never gets here */
; 2005 : 
; 2006 : 
; 2007 :     /* Match an extended character class. This opcode is encountered only
; 2008 :     in UTF-8 mode, because that's the only time it is compiled. */
; 2009 : 
; 2010 : #ifdef SUPPORT_UTF8
; 2011 :     case OP_XCLASS:
; 2012 :       {
; 2013 :       data = ecode + 1 + LINK_SIZE;                /* Save for matching */
; 2014 :       ecode += GET(ecode, 1);                      /* Advance past the item */
; 2015 : 
; 2016 :       switch (*ecode)
; 2017 :         {
; 2018 :         case OP_CRSTAR:
; 2019 :         case OP_CRMINSTAR:
; 2020 :         case OP_CRPLUS:
; 2021 :         case OP_CRMINPLUS:
; 2022 :         case OP_CRQUERY:
; 2023 :         case OP_CRMINQUERY:
; 2024 :         c = *ecode++ - OP_CRSTAR;
; 2025 :         minimize = (c & 1) != 0;
; 2026 :         min = rep_min[c];                 /* Pick up values from tables; */
; 2027 :         max = rep_max[c];                 /* zero for max => infinity */
; 2028 :         if (max == 0) max = INT_MAX;
; 2029 :         break;
; 2030 : 
; 2031 :         case OP_CRRANGE:
; 2032 :         case OP_CRMINRANGE:
; 2033 :         minimize = (*ecode == OP_CRMINRANGE);
; 2034 :         min = GET2(ecode, 1);
; 2035 :         max = GET2(ecode, 3);
; 2036 :         if (max == 0) max = INT_MAX;
; 2037 :         ecode += 5;
; 2038 :         break;
; 2039 : 
; 2040 :         default:               /* No repeat follows */
; 2041 :         min = max = 1;
; 2042 :         break;
; 2043 :         }
; 2044 : 
; 2045 :       /* First, ensure the minimum number of matches are present. */
; 2046 : 
; 2047 :       for (i = 1; i <= min; i++)
; 2048 :         {
; 2049 :         if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2050 :         GETCHARINC(c, eptr);
; 2051 :         if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
; 2052 :         }
; 2053 : 
; 2054 :       /* If max == min we can continue with the main loop without the
; 2055 :       need to recurse. */
; 2056 : 
; 2057 :       if (min == max) continue;
; 2058 : 
; 2059 :       /* If minimizing, keep testing the rest of the expression and advancing
; 2060 :       the pointer while it matches the class. */
; 2061 : 
; 2062 :       if (minimize)
; 2063 :         {
; 2064 :         for (fi = min;; fi++)
; 2065 :           {
; 2066 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
; 2067 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2068 :           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2069 :           GETCHARINC(c, eptr);
; 2070 :           if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
; 2071 :           }
; 2072 :         /* Control never gets here */
; 2073 :         }
; 2074 : 
; 2075 :       /* If maximizing, find the longest possible run, then work backwards. */
; 2076 : 
; 2077 :       else
; 2078 :         {
; 2079 :         pp = eptr;
; 2080 :         for (i = min; i < max; i++)
; 2081 :           {
; 2082 :           int len = 1;
; 2083 :           if (eptr >= md->end_subject) break;
; 2084 :           GETCHARLEN(c, eptr, len);
; 2085 :           if (!_pcre_xclass(c, data)) break;
; 2086 :           eptr += len;
; 2087 :           }
; 2088 :         for(;;)
; 2089 :           {
; 2090 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
; 2091 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2092 :           if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 2093 :           if (utf8) BACKCHAR(eptr);
; 2094 :           }
; 2095 :         RRETURN(MATCH_NOMATCH);
; 2096 :         }
; 2097 : 
; 2098 :       /* Control never gets here */
; 2099 :       }
; 2100 : #endif    /* End of XCLASS */
; 2101 : 
; 2102 :     /* Match a single character, casefully */
; 2103 : 
; 2104 :     case OP_CHAR:
; 2105 : #ifdef SUPPORT_UTF8
; 2106 :     if (utf8)
; 2107 :       {
; 2108 :       length = 1;
; 2109 :       ecode++;
; 2110 :       GETCHARLEN(fc, ecode, length);
; 2111 :       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
; 2112 :       while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
; 2113 :       }
; 2114 :     else
; 2115 : #endif
; 2116 : 
; 2117 :     /* Non-UTF-8 mode */
; 2118 :       {
; 2119 :       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+88]
	sub	ecx, esi
	cmp	ecx, 1
	jl	$LN645@match

; 2120 :       if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);

	mov	dl, BYTE PTR [esi]
	add	esi, 1
	cmp	BYTE PTR [edi+1], dl
	jne	$LN645@match

; 2121 :       ecode += 2;

	add	edi, 2

; 2122 :       }
; 2123 :     break;

	jmp	$LL650@match
$LN364@match:

; 2124 : 
; 2125 :     /* Match a single character, caselessly */
; 2126 : 
; 2127 :     case OP_CHARNC:
; 2128 : #ifdef SUPPORT_UTF8
; 2129 :     if (utf8)
; 2130 :       {
; 2131 :       length = 1;
; 2132 :       ecode++;
; 2133 :       GETCHARLEN(fc, ecode, length);
; 2134 : 
; 2135 :       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
; 2136 : 
; 2137 :       /* If the pattern character's value is < 128, we have only one byte, and
; 2138 :       can use the fast lookup table. */
; 2139 : 
; 2140 :       if (fc < 128)
; 2141 :         {
; 2142 :         if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
; 2143 :         }
; 2144 : 
; 2145 :       /* Otherwise we must pick up the subject character */
; 2146 : 
; 2147 :       else
; 2148 :         {
; 2149 :         unsigned int dc;
; 2150 :         GETCHARINC(dc, eptr);
; 2151 :         ecode += length;
; 2152 : 
; 2153 :         /* If we have Unicode property support, we can use it to test the other
; 2154 :         case of the character, if there is one. */
; 2155 : 
; 2156 :         if (fc != dc)
; 2157 :           {
; 2158 : #ifdef SUPPORT_UCP
; 2159 :           if (dc != _pcre_ucp_othercase(fc))
; 2160 : #endif
; 2161 :             RRETURN(MATCH_NOMATCH);
; 2162 :           }
; 2163 :         }
; 2164 :       }
; 2165 :     else
; 2166 : #endif   /* SUPPORT_UTF8 */
; 2167 : 
; 2168 :     /* Non-UTF-8 mode */
; 2169 :       {
; 2170 :       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);

	mov	eax, DWORD PTR [ebp+88]
	sub	eax, esi
	cmp	eax, 1
	jl	$LN645@match

; 2171 :       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	eax, DWORD PTR [ebp+36]
	movzx	ecx, BYTE PTR [edi+1]
	mov	dl, BYTE PTR [edx+eax]
	add	esi, 1
	cmp	BYTE PTR [ecx+eax], dl
	jne	$LN645@match

; 2172 :       ecode += 2;

	add	edi, 2

; 2173 :       }
; 2174 :     break;

	jmp	$LL650@match
$LN361@match:

; 2175 : 
; 2176 :     /* Match a single character repeatedly. */
; 2177 : 
; 2178 :     case OP_EXACT:
; 2179 :     min = max = GET2(ecode, 1);

	xor	ebx, ebx
	mov	bh, BYTE PTR [edi+1]

; 2180 :     ecode += 3;

	add	edi, 3
	mov	bl, BYTE PTR [edi-1]
	mov	eax, ebx

; 2181 :     goto REPEATCHAR;

	jmp	$REPEATCHAR$5770
$LN360@match:

; 2182 : 
; 2183 :     case OP_POSUPTO:
; 2184 :     possessive = TRUE;

	mov	DWORD PTR _possessive$[esp+244], 1
$LN359@match:

; 2185 :     /* Fall through */
; 2186 : 
; 2187 :     case OP_UPTO:
; 2188 :     case OP_MINUPTO:
; 2189 :     min = 0;
; 2190 :     max = GET2(ecode, 1);

	xor	ebx, ebx
	mov	bh, BYTE PTR [edi+1]

; 2191 :     minimize = *ecode == OP_MINUPTO;

	xor	edx, edx
	xor	eax, eax
	cmp	BYTE PTR [edi], 37			; 00000025H
	sete	dl

; 2192 :     ecode += 3;

	add	edi, 3
	mov	bl, BYTE PTR [edi-1]
	mov	DWORD PTR _minimize$[esp+244], edx

; 2193 :     goto REPEATCHAR;

	jmp	SHORT $REPEATCHAR$5770
$LN358@match:

; 2194 : 
; 2195 :     case OP_POSSTAR:
; 2196 :     possessive = TRUE;
; 2197 :     min = 0;

	xor	eax, eax
	mov	DWORD PTR _possessive$[esp+244], 1

; 2198 :     max = INT_MAX;
; 2199 :     ecode++;

	add	edi, 1

; 2200 :     goto REPEATCHAR;

	jmp	SHORT $LN1426@match
$LN357@match:

; 2201 : 
; 2202 :     case OP_POSPLUS:
; 2203 :     possessive = TRUE;

	mov	eax, 1
	mov	DWORD PTR _possessive$[esp+244], eax

; 2204 :     min = 1;
; 2205 :     max = INT_MAX;
; 2206 :     ecode++;

	add	edi, eax

; 2207 :     goto REPEATCHAR;

	jmp	SHORT $LN1426@match
$LN356@match:

; 2208 : 
; 2209 :     case OP_POSQUERY:
; 2210 :     possessive = TRUE;

	mov	ebx, 1

; 2211 :     min = 0;

	xor	eax, eax
	mov	DWORD PTR _possessive$[esp+244], ebx

; 2212 :     max = 1;
; 2213 :     ecode++;

	add	edi, ebx

; 2214 :     goto REPEATCHAR;

	jmp	SHORT $REPEATCHAR$5770
$LN355@match:

; 2215 : 
; 2216 :     case OP_STAR:
; 2217 :     case OP_MINSTAR:
; 2218 :     case OP_PLUS:
; 2219 :     case OP_MINPLUS:
; 2220 :     case OP_QUERY:
; 2221 :     case OP_MINQUERY:
; 2222 :     c = *ecode++ - OP_STAR;

	movzx	ecx, BYTE PTR [edi]

; 2223 :     minimize = (c & 1) != 0;
; 2224 :     min = rep_min[c];                 /* Pick up values from tables; */
; 2225 :     max = rep_max[c];                 /* zero for max => infinity */

	movsx	ebx, BYTE PTR _rep_max[ecx-30]
	movsx	eax, BYTE PTR _rep_min[ecx-30]
	sub	ecx, 30					; 0000001eH
	mov	edx, ecx
	and	edx, 1
	add	edi, 1

; 2226 :     if (max == 0) max = INT_MAX;

	test	ebx, ebx
	mov	DWORD PTR _minimize$[esp+244], edx
	jne	SHORT $REPEATCHAR$5770
$LN1426@match:
	mov	ebx, 2147483647				; 7fffffffH
$REPEATCHAR$5770:

; 2227 : 
; 2228 :     /* Common code for all repeated single-character matches. We can give
; 2229 :     up quickly if there are fewer than the minimum number of characters left in
; 2230 :     the subject. */
; 2231 : 
; 2232 :     REPEATCHAR:
; 2233 : #ifdef SUPPORT_UTF8
; 2234 :     if (utf8)
; 2235 :       {
; 2236 :       length = 1;
; 2237 :       charptr = ecode;
; 2238 :       GETCHARLEN(fc, ecode, length);
; 2239 :       if (min * length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
; 2240 :       ecode += length;
; 2241 : 
; 2242 :       /* Handle multibyte character matching specially here. There is
; 2243 :       support for caseless matching if UCP support is present. */
; 2244 : 
; 2245 :       if (length > 1)
; 2246 :         {
; 2247 : #ifdef SUPPORT_UCP
; 2248 :         unsigned int othercase;
; 2249 :         if ((ims & PCRE_CASELESS) != 0 &&
; 2250 :             (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)
; 2251 :           oclength = _pcre_ord2utf8(othercase, occhars);
; 2252 :         else oclength = 0;
; 2253 : #endif  /* SUPPORT_UCP */
; 2254 : 
; 2255 :         for (i = 1; i <= min; i++)
; 2256 :           {
; 2257 :           if (memcmp(eptr, charptr, length) == 0) eptr += length;
; 2258 : #ifdef SUPPORT_UCP
; 2259 :           /* Need braces because of following else */
; 2260 :           else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
; 2261 :           else
; 2262 :             {
; 2263 :             if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
; 2264 :             eptr += oclength;
; 2265 :             }
; 2266 : #else   /* without SUPPORT_UCP */
; 2267 :           else { RRETURN(MATCH_NOMATCH); }
; 2268 : #endif  /* SUPPORT_UCP */
; 2269 :           }
; 2270 : 
; 2271 :         if (min == max) continue;
; 2272 : 
; 2273 :         if (minimize)
; 2274 :           {
; 2275 :           for (fi = min;; fi++)
; 2276 :             {
; 2277 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
; 2278 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2279 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2280 :             if (memcmp(eptr, charptr, length) == 0) eptr += length;
; 2281 : #ifdef SUPPORT_UCP
; 2282 :             /* Need braces because of following else */
; 2283 :             else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
; 2284 :             else
; 2285 :               {
; 2286 :               if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
; 2287 :               eptr += oclength;
; 2288 :               }
; 2289 : #else   /* without SUPPORT_UCP */
; 2290 :             else { RRETURN (MATCH_NOMATCH); }
; 2291 : #endif  /* SUPPORT_UCP */
; 2292 :             }
; 2293 :           /* Control never gets here */
; 2294 :           }
; 2295 : 
; 2296 :         else  /* Maximize */
; 2297 :           {
; 2298 :           pp = eptr;
; 2299 :           for (i = min; i < max; i++)
; 2300 :             {
; 2301 :             if (eptr > md->end_subject - length) break;
; 2302 :             if (memcmp(eptr, charptr, length) == 0) eptr += length;
; 2303 : #ifdef SUPPORT_UCP
; 2304 :             else if (oclength == 0) break;
; 2305 :             else
; 2306 :               {
; 2307 :               if (memcmp(eptr, occhars, oclength) != 0) break;
; 2308 :               eptr += oclength;
; 2309 :               }
; 2310 : #else   /* without SUPPORT_UCP */
; 2311 :             else break;
; 2312 : #endif  /* SUPPORT_UCP */
; 2313 :             }
; 2314 : 
; 2315 :           if (possessive) continue;
; 2316 :           for(;;)
; 2317 :            {
; 2318 :            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
; 2319 :            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2320 :            if (eptr == pp) RRETURN(MATCH_NOMATCH);
; 2321 : #ifdef SUPPORT_UCP
; 2322 :            eptr--;
; 2323 :            BACKCHAR(eptr);
; 2324 : #else   /* without SUPPORT_UCP */
; 2325 :            eptr -= length;
; 2326 : #endif  /* SUPPORT_UCP */
; 2327 :            }
; 2328 :           }
; 2329 :         /* Control never gets here */
; 2330 :         }
; 2331 : 
; 2332 :       /* If the length of a UTF-8 character is 1, we fall through here, and
; 2333 :       obey the code as for non-UTF-8 characters below, though in this case the
; 2334 :       value of fc will always be < 128. */
; 2335 :       }
; 2336 :     else
; 2337 : #endif  /* SUPPORT_UTF8 */
; 2338 : 
; 2339 :     /* When not in UTF-8 mode, load a single-byte character. */
; 2340 :       {
; 2341 :       if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+88]
	sub	ecx, esi
	cmp	eax, ecx
	jg	$LN645@match

; 2342 :       fc = *ecode++;

	movzx	ecx, BYTE PTR [edi]
	add	edi, 1

; 2343 :       }
; 2344 : 
; 2345 :     /* The value of fc at this point is always less than 256, though we may or
; 2346 :     may not be in UTF-8 mode. The code is duplicated for the caseless and
; 2347 :     caseful cases, for speed, since matching characters is likely to be quite
; 2348 :     common. First, ensure the minimum number of matches are present. If min =
; 2349 :     max, continue at the same level without recursing. Otherwise, if
; 2350 :     minimizing, keep trying the rest of the expression and advancing one
; 2351 :     matching character if failing, up to the maximum. Alternatively, if
; 2352 :     maximizing, find the maximum number of characters and work backwards. */
; 2353 : 
; 2354 :     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
; 2355 :       max, eptr));
; 2356 : 
; 2357 :     if ((ims & PCRE_CASELESS) != 0)

	test	BYTE PTR _ims$[esp+240], 1
	mov	DWORD PTR _c$[esp+244], ecx

; 2358 :       {
; 2359 :       fc = md->lcc[fc];
; 2360 :       for (i = 1; i <= min; i++)

	mov	DWORD PTR _i$[esp+244], 1
	je	$LN352@match
	cmp	eax, 1
	mov	edx, DWORD PTR [ebp+36]
	movzx	edx, BYTE PTR [edx+ecx]
	mov	DWORD PTR _c$[esp+244], edx
	jl	SHORT $LN349@match
$LL351@match:

; 2361 :         if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+36]
	movzx	ecx, BYTE PTR [edx+ecx]
	add	esi, 1
	cmp	DWORD PTR _c$[esp+244], ecx
	jne	$LN645@match
	mov	ecx, DWORD PTR _i$[esp+244]
	add	ecx, 1
	cmp	ecx, eax
	mov	DWORD PTR _i$[esp+244], ecx
	jle	SHORT $LL351@match
$LN349@match:

; 2362 :       if (min == max) continue;

	cmp	eax, ebx
	je	$LL650@match

; 2363 :       if (minimize)

	cmp	DWORD PTR _minimize$[esp+244], 0
	jne	$LN930@match

; 2371 :             RRETURN(MATCH_NOMATCH);
; 2372 :           }
; 2373 :         /* Control never gets here */
; 2374 :         }
; 2375 :       else  /* Maximize */
; 2376 :         {
; 2377 :         pp = eptr;
; 2378 :         for (i = min; i < max; i++)

	cmp	eax, ebx
	mov	DWORD PTR _pp$[esp+244], esi
	jge	SHORT $LN1337@match
$LL1336@match:

; 2379 :           {
; 2380 :           if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1337@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+36]
	movzx	ecx, BYTE PTR [edx+ecx]
	cmp	DWORD PTR _c$[esp+244], ecx
	jne	SHORT $LN1337@match
	add	eax, 1

; 2381 :           eptr++;

	add	esi, 1
	cmp	eax, ebx
	jl	SHORT $LL1336@match
$LN1337@match:

; 2382 :           }
; 2383 :         if (possessive) continue;

	cmp	DWORD PTR _possessive$[esp+244], 0
	jne	$LL650@match

; 2384 :         while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jb	SHORT $LN331@match
	mov	ebx, DWORD PTR _rdepth$[esp+240]
	add	ebx, 1
	npad	2
$LL332@match:

; 2385 :           {
; 2386 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);

	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset_top$[esp+240]
	push	ebx
	push	0
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2387 :           eptr--;

	sub	esi, 1

; 2388 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 2384 :         while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL332@match
$LN331@match:
	pop	edi
	pop	esi
	pop	ebp

; 2389 :           }
; 2390 :         RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN352@match:

; 2391 :         }
; 2392 :       /* Control never gets here */
; 2393 :       }
; 2394 : 
; 2395 :     /* Caseful comparisons (includes all multi-byte characters) */
; 2396 : 
; 2397 :     else
; 2398 :       {
; 2399 :       for (i = 1; i <= min; i++) if (fc != *eptr++) RRETURN(MATCH_NOMATCH);

	cmp	eax, 1
	jl	SHORT $LN326@match
$LL328@match:
	movzx	edx, BYTE PTR [esi]
	add	esi, 1
	cmp	ecx, edx
	jne	$LN645@match
	mov	edx, DWORD PTR _i$[esp+244]
	add	edx, 1
	cmp	edx, eax
	mov	DWORD PTR _i$[esp+244], edx
	jle	SHORT $LL328@match
	mov	edx, DWORD PTR _minimize$[esp+244]
$LN326@match:

; 2400 :       if (min == max) continue;

	cmp	eax, ebx
	je	$LL650@match

; 2401 :       if (minimize)

	test	edx, edx
	jne	$LN931@match

; 2408 :             RRETURN(MATCH_NOMATCH);
; 2409 :           }
; 2410 :         /* Control never gets here */
; 2411 :         }
; 2412 :       else  /* Maximize */
; 2413 :         {
; 2414 :         pp = eptr;
; 2415 :         for (i = min; i < max; i++)

	cmp	eax, ebx
	mov	ecx, esi
	mov	DWORD PTR _pp$[esp+244], ecx
	jge	SHORT $LN1333@match
	npad	4
$LL1332@match:

; 2416 :           {
; 2417 :           if (eptr >= md->end_subject || fc != *eptr) break;

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1333@match
	movzx	edx, BYTE PTR [esi]
	cmp	DWORD PTR _c$[esp+244], edx
	jne	SHORT $LN1333@match
	add	eax, 1

; 2418 :           eptr++;

	add	esi, 1
	cmp	eax, ebx
	jl	SHORT $LL1332@match
$LN1333@match:

; 2419 :           }
; 2420 :         if (possessive) continue;

	cmp	DWORD PTR _possessive$[esp+244], 0
	jne	$LL650@match

; 2421 :         while (eptr >= pp)

	cmp	esi, ecx
	jb	SHORT $LN308@match
	mov	ebx, DWORD PTR _rdepth$[esp+240]
	add	ebx, 1
$LL309@match:

; 2422 :           {
; 2423 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);

	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	mov	ecx, DWORD PTR _offset_top$[esp+240]
	push	ebx
	push	0
	push	edx
	mov	edx, DWORD PTR _mstart$[esp+252]
	push	eax
	push	ebp
	push	ecx
	push	edx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2424 :           eptr--;

	sub	esi, 1

; 2425 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 2421 :         while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL309@match
$LN308@match:
	pop	edi
	pop	esi
	pop	ebp

; 2426 :           }
; 2427 :         RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN316@match:

; 2428 :         }
; 2429 :       }
; 2430 :     /* Control never gets here */
; 2431 : 
; 2432 :     /* Match a negated single one-byte character. The character we are
; 2433 :     checking can be multibyte. */
; 2434 : 
; 2435 :     case OP_NOT:
; 2436 :     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match

; 2437 :     ecode++;
; 2438 :     GETCHARINCTEST(c, eptr);

	movzx	ecx, BYTE PTR [esi]

; 2439 :     if ((ims & PCRE_CASELESS) != 0)
; 2440 :       {
; 2441 : #ifdef SUPPORT_UTF8
; 2442 :       if (c < 256)
; 2443 : #endif
; 2444 :       c = md->lcc[c];
; 2445 :       if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [edi+1]
	add	edi, 1
	add	esi, 1
	add	edi, 1
	test	BYTE PTR _ims$[esp+240], 1
	je	SHORT $LN304@match
	mov	eax, DWORD PTR [ebp+36]
	mov	cl, BYTE PTR [eax+ecx]
	cmp	BYTE PTR [edx+eax], cl
	jne	$LL650@match
	pop	edi
	pop	esi
	pop	ebp
	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN304@match:

; 2446 :       }
; 2447 :     else
; 2448 :       {
; 2449 :       if (*ecode++ == c) RRETURN(MATCH_NOMATCH);

	cmp	edx, ecx
	jne	$LL650@match
	pop	edi
	pop	esi
	pop	ebp
	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN300@match:

; 2450 :       }
; 2451 :     break;
; 2452 : 
; 2453 :     /* Match a negated single one-byte character repeatedly. This is almost a
; 2454 :     repeat of the code for a repeated single character, but I haven't found a
; 2455 :     nice way of commoning these up that doesn't require a test of the
; 2456 :     positive/negative option for each character match. Maybe that wouldn't add
; 2457 :     very much to the time taken, but character matching *is* what this is all
; 2458 :     about... */
; 2459 : 
; 2460 :     case OP_NOTEXACT:
; 2461 :     min = max = GET2(ecode, 1);

	xor	ebx, ebx
	mov	bh, BYTE PTR [edi+1]

; 2462 :     ecode += 3;

	add	edi, 3
	mov	bl, BYTE PTR [edi-1]
	mov	eax, ebx

; 2463 :     goto REPEATNOTCHAR;

	jmp	$REPEATNOTCHAR$5834
$LN299@match:

; 2464 : 
; 2465 :     case OP_NOTUPTO:
; 2466 :     case OP_NOTMINUPTO:
; 2467 :     min = 0;
; 2468 :     max = GET2(ecode, 1);

	xor	ebx, ebx
	mov	bh, BYTE PTR [edi+1]

; 2469 :     minimize = *ecode == OP_NOTMINUPTO;

	xor	edx, edx
	xor	eax, eax
	cmp	BYTE PTR [edi], 50			; 00000032H
	sete	dl

; 2470 :     ecode += 3;

	add	edi, 3
	mov	bl, BYTE PTR [edi-1]
	mov	DWORD PTR _minimize$[esp+244], edx

; 2471 :     goto REPEATNOTCHAR;

	jmp	$REPEATNOTCHAR$5834
$LN298@match:

; 2472 : 
; 2473 :     case OP_NOTPOSSTAR:
; 2474 :     possessive = TRUE;
; 2475 :     min = 0;

	xor	eax, eax
	mov	DWORD PTR _possessive$[esp+244], 1

; 2476 :     max = INT_MAX;
; 2477 :     ecode++;

	add	edi, 1

; 2478 :     goto REPEATNOTCHAR;

	jmp	SHORT $LN1427@match
$LN297@match:

; 2479 : 
; 2480 :     case OP_NOTPOSPLUS:
; 2481 :     possessive = TRUE;

	mov	eax, 1
	mov	DWORD PTR _possessive$[esp+244], eax

; 2482 :     min = 1;
; 2483 :     max = INT_MAX;
; 2484 :     ecode++;

	add	edi, eax

; 2485 :     goto REPEATNOTCHAR;

	jmp	SHORT $LN1427@match
$LN296@match:

; 2486 : 
; 2487 :     case OP_NOTPOSQUERY:
; 2488 :     possessive = TRUE;

	mov	ebx, 1

; 2489 :     min = 0;

	xor	eax, eax
	mov	DWORD PTR _possessive$[esp+244], ebx

; 2490 :     max = 1;
; 2491 :     ecode++;

	add	edi, ebx

; 2492 :     goto REPEATNOTCHAR;

	jmp	SHORT $REPEATNOTCHAR$5834
$LN295@match:

; 2493 : 
; 2494 :     case OP_NOTPOSUPTO:
; 2495 :     possessive = TRUE;
; 2496 :     min = 0;
; 2497 :     max = GET2(ecode, 1);

	xor	ebx, ebx
	mov	bh, BYTE PTR [edi+1]
	xor	eax, eax
	mov	DWORD PTR _possessive$[esp+244], 1

; 2498 :     ecode += 3;

	add	edi, 3
	mov	bl, BYTE PTR [edi-1]

; 2499 :     goto REPEATNOTCHAR;

	jmp	SHORT $REPEATNOTCHAR$5834
$LN294@match:

; 2500 : 
; 2501 :     case OP_NOTSTAR:
; 2502 :     case OP_NOTMINSTAR:
; 2503 :     case OP_NOTPLUS:
; 2504 :     case OP_NOTMINPLUS:
; 2505 :     case OP_NOTQUERY:
; 2506 :     case OP_NOTMINQUERY:
; 2507 :     c = *ecode++ - OP_NOTSTAR;

	movzx	ecx, BYTE PTR [edi]

; 2508 :     minimize = (c & 1) != 0;
; 2509 :     min = rep_min[c];                 /* Pick up values from tables; */
; 2510 :     max = rep_max[c];                 /* zero for max => infinity */

	movsx	ebx, BYTE PTR _rep_max[ecx-43]
	movsx	eax, BYTE PTR _rep_min[ecx-43]
	sub	ecx, 43					; 0000002bH
	mov	edx, ecx
	and	edx, 1
	add	edi, 1

; 2511 :     if (max == 0) max = INT_MAX;

	test	ebx, ebx
	mov	DWORD PTR _minimize$[esp+244], edx
	jne	SHORT $REPEATNOTCHAR$5834
$LN1427@match:
	mov	ebx, 2147483647				; 7fffffffH
$REPEATNOTCHAR$5834:

; 2512 : 
; 2513 :     /* Common code for all repeated single-byte matches. We can give up quickly
; 2514 :     if there are fewer than the minimum number of bytes left in the
; 2515 :     subject. */
; 2516 : 
; 2517 :     REPEATNOTCHAR:
; 2518 :     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+88]
	sub	ecx, esi
	cmp	eax, ecx
	jg	$LN645@match

; 2519 :     fc = *ecode++;

	movzx	ecx, BYTE PTR [edi]
	add	edi, 1

; 2520 : 
; 2521 :     /* The code is duplicated for the caseless and caseful cases, for speed,
; 2522 :     since matching characters is likely to be quite common. First, ensure the
; 2523 :     minimum number of matches are present. If min = max, continue at the same
; 2524 :     level without recursing. Otherwise, if minimizing, keep trying the rest of
; 2525 :     the expression and advancing one matching character if failing, up to the
; 2526 :     maximum. Alternatively, if maximizing, find the maximum number of
; 2527 :     characters and work backwards. */
; 2528 : 
; 2529 :     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
; 2530 :       max, eptr));
; 2531 : 
; 2532 :     if ((ims & PCRE_CASELESS) != 0)

	test	BYTE PTR _ims$[esp+240], 1
	mov	DWORD PTR _c$[esp+244], ecx

; 2533 :       {
; 2534 :       fc = md->lcc[fc];
; 2535 : 
; 2536 : #ifdef SUPPORT_UTF8
; 2537 :       /* UTF-8 mode */
; 2538 :       if (utf8)
; 2539 :         {
; 2540 :         register unsigned int d;
; 2541 :         for (i = 1; i <= min; i++)
; 2542 :           {
; 2543 :           GETCHARINC(d, eptr);
; 2544 :           if (d < 256) d = md->lcc[d];
; 2545 :           if (fc == d) RRETURN(MATCH_NOMATCH);
; 2546 :           }
; 2547 :         }
; 2548 :       else
; 2549 : #endif
; 2550 : 
; 2551 :       /* Not UTF-8 mode */
; 2552 :         {
; 2553 :         for (i = 1; i <= min; i++)

	mov	DWORD PTR _i$[esp+244], 1
	je	$LN291@match
	cmp	eax, 1
	mov	edx, DWORD PTR [ebp+36]
	movzx	edx, BYTE PTR [edx+ecx]
	mov	DWORD PTR _c$[esp+244], edx
	jl	SHORT $LN288@match
	npad	7
$LL290@match:

; 2554 :           if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+36]
	movzx	ecx, BYTE PTR [edx+ecx]
	add	esi, 1
	cmp	DWORD PTR _c$[esp+244], ecx
	je	$LN645@match
	mov	ecx, DWORD PTR _i$[esp+244]
	add	ecx, 1
	cmp	ecx, eax
	mov	DWORD PTR _i$[esp+244], ecx
	jle	SHORT $LL290@match
$LN288@match:

; 2555 :         }
; 2556 : 
; 2557 :       if (min == max) continue;

	cmp	eax, ebx
	je	$LL650@match

; 2558 : 
; 2559 :       if (minimize)

	cmp	DWORD PTR _minimize$[esp+244], 0
	jne	$LN936@match

; 2585 :               RRETURN(MATCH_NOMATCH);
; 2586 :             }
; 2587 :           }
; 2588 :         /* Control never gets here */
; 2589 :         }
; 2590 : 
; 2591 :       /* Maximize case */
; 2592 : 
; 2593 :       else
; 2594 :         {
; 2595 :         pp = eptr;
; 2596 : 
; 2597 : #ifdef SUPPORT_UTF8
; 2598 :         /* UTF-8 mode */
; 2599 :         if (utf8)
; 2600 :           {
; 2601 :           register unsigned int d;
; 2602 :           for (i = min; i < max; i++)
; 2603 :             {
; 2604 :             int len = 1;
; 2605 :             if (eptr >= md->end_subject) break;
; 2606 :             GETCHARLEN(d, eptr, len);
; 2607 :             if (d < 256) d = md->lcc[d];
; 2608 :             if (fc == d) break;
; 2609 :             eptr += len;
; 2610 :             }
; 2611 :         if (possessive) continue;
; 2612 :         for(;;)
; 2613 :             {
; 2614 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
; 2615 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2616 :             if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 2617 :             BACKCHAR(eptr);
; 2618 :             }
; 2619 :           }
; 2620 :         else
; 2621 : #endif
; 2622 :         /* Not UTF-8 mode */
; 2623 :           {
; 2624 :           for (i = min; i < max; i++)

	cmp	eax, ebx
	mov	DWORD PTR _pp$[esp+244], esi
	jge	SHORT $LN1335@match
$LL1334@match:

; 2625 :             {
; 2626 :             if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1335@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+36]
	movzx	ecx, BYTE PTR [edx+ecx]
	cmp	DWORD PTR _c$[esp+244], ecx
	je	SHORT $LN1335@match
	add	eax, 1

; 2627 :             eptr++;

	add	esi, 1
	cmp	eax, ebx
	jl	SHORT $LL1334@match
$LN1335@match:

; 2628 :             }
; 2629 :           if (possessive) continue;

	cmp	DWORD PTR _possessive$[esp+244], 0
	jne	$LL650@match

; 2630 :           while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jb	SHORT $LN270@match
	mov	ebx, DWORD PTR _rdepth$[esp+240]
	add	ebx, 1
	npad	5
$LL271@match:

; 2631 :             {
; 2632 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);

	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset_top$[esp+240]
	push	ebx
	push	0
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2633 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 2634 :             eptr--;

	sub	esi, 1
	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL271@match
$LN270@match:
	pop	edi
	pop	esi
	pop	ebp

; 2635 :             }
; 2636 :           }
; 2637 : 
; 2638 :         RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN291@match:

; 2639 :         }
; 2640 :       /* Control never gets here */
; 2641 :       }
; 2642 : 
; 2643 :     /* Caseful comparisons */
; 2644 : 
; 2645 :     else
; 2646 :       {
; 2647 : #ifdef SUPPORT_UTF8
; 2648 :       /* UTF-8 mode */
; 2649 :       if (utf8)
; 2650 :         {
; 2651 :         register unsigned int d;
; 2652 :         for (i = 1; i <= min; i++)
; 2653 :           {
; 2654 :           GETCHARINC(d, eptr);
; 2655 :           if (fc == d) RRETURN(MATCH_NOMATCH);
; 2656 :           }
; 2657 :         }
; 2658 :       else
; 2659 : #endif
; 2660 :       /* Not UTF-8 mode */
; 2661 :         {
; 2662 :         for (i = 1; i <= min; i++)

	cmp	eax, 1
	jl	SHORT $LN265@match
$LL267@match:

; 2663 :           if (fc == *eptr++) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	add	esi, 1
	cmp	ecx, edx
	je	$LN645@match
	mov	edx, DWORD PTR _i$[esp+244]
	add	edx, 1
	cmp	edx, eax
	mov	DWORD PTR _i$[esp+244], edx
	jle	SHORT $LL267@match

; 2639 :         }
; 2640 :       /* Control never gets here */
; 2641 :       }
; 2642 : 
; 2643 :     /* Caseful comparisons */
; 2644 : 
; 2645 :     else
; 2646 :       {
; 2647 : #ifdef SUPPORT_UTF8
; 2648 :       /* UTF-8 mode */
; 2649 :       if (utf8)
; 2650 :         {
; 2651 :         register unsigned int d;
; 2652 :         for (i = 1; i <= min; i++)
; 2653 :           {
; 2654 :           GETCHARINC(d, eptr);
; 2655 :           if (fc == d) RRETURN(MATCH_NOMATCH);
; 2656 :           }
; 2657 :         }
; 2658 :       else
; 2659 : #endif
; 2660 :       /* Not UTF-8 mode */
; 2661 :         {
; 2662 :         for (i = 1; i <= min; i++)

	mov	edx, DWORD PTR _minimize$[esp+244]
$LN265@match:

; 2664 :         }
; 2665 : 
; 2666 :       if (min == max) continue;

	cmp	eax, ebx
	je	$LL650@match

; 2667 : 
; 2668 :       if (minimize)

	test	edx, edx
	jne	$LN937@match

; 2693 :               RRETURN(MATCH_NOMATCH);
; 2694 :             }
; 2695 :           }
; 2696 :         /* Control never gets here */
; 2697 :         }
; 2698 : 
; 2699 :       /* Maximize case */
; 2700 : 
; 2701 :       else
; 2702 :         {
; 2703 :         pp = eptr;
; 2704 : 
; 2705 : #ifdef SUPPORT_UTF8
; 2706 :         /* UTF-8 mode */
; 2707 :         if (utf8)
; 2708 :           {
; 2709 :           register unsigned int d;
; 2710 :           for (i = min; i < max; i++)
; 2711 :             {
; 2712 :             int len = 1;
; 2713 :             if (eptr >= md->end_subject) break;
; 2714 :             GETCHARLEN(d, eptr, len);
; 2715 :             if (fc == d) break;
; 2716 :             eptr += len;
; 2717 :             }
; 2718 :           if (possessive) continue;
; 2719 :           for(;;)
; 2720 :             {
; 2721 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
; 2722 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2723 :             if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 2724 :             BACKCHAR(eptr);
; 2725 :             }
; 2726 :           }
; 2727 :         else
; 2728 : #endif
; 2729 :         /* Not UTF-8 mode */
; 2730 :           {
; 2731 :           for (i = min; i < max; i++)

	cmp	eax, ebx
	mov	ecx, esi
	mov	DWORD PTR _pp$[esp+244], ecx
	jge	SHORT $LN1331@match
	npad	4
$LL1330@match:

; 2732 :             {
; 2733 :             if (eptr >= md->end_subject || fc == *eptr) break;

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1331@match
	movzx	edx, BYTE PTR [esi]
	cmp	DWORD PTR _c$[esp+244], edx
	je	SHORT $LN1331@match
	add	eax, 1

; 2734 :             eptr++;

	add	esi, 1
	cmp	eax, ebx
	jl	SHORT $LL1330@match
$LN1331@match:

; 2735 :             }
; 2736 :           if (possessive) continue;

	cmp	DWORD PTR _possessive$[esp+244], 0
	jne	$LL650@match

; 2737 :           while (eptr >= pp)

	cmp	esi, ecx
	jb	SHORT $LN247@match
	mov	ebx, DWORD PTR _rdepth$[esp+240]
	add	ebx, 1
$LL248@match:

; 2738 :             {
; 2739 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);

	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	mov	ecx, DWORD PTR _offset_top$[esp+240]
	push	ebx
	push	0
	push	edx
	mov	edx, DWORD PTR _mstart$[esp+252]
	push	eax
	push	ebp
	push	ecx
	push	edx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2740 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 2741 :             eptr--;

	sub	esi, 1
	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL248@match
$LN247@match:
	pop	edi
	pop	esi
	pop	ebp

; 2742 :             }
; 2743 :           }
; 2744 : 
; 2745 :         RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN255@match:

; 2746 :         }
; 2747 :       }
; 2748 :     /* Control never gets here */
; 2749 : 
; 2750 :     /* Match a single character type repeatedly; several different opcodes
; 2751 :     share code. This is very similar to the code for single characters, but we
; 2752 :     repeat it in the interests of efficiency. */
; 2753 : 
; 2754 :     case OP_TYPEEXACT:
; 2755 :     min = max = GET2(ecode, 1);

	xor	ebx, ebx
	mov	bh, BYTE PTR [edi+1]

; 2756 :     minimize = TRUE;

	mov	DWORD PTR _minimize$[esp+244], 1

; 2757 :     ecode += 3;

	add	edi, 3
	mov	bl, BYTE PTR [edi-1]
	mov	DWORD PTR _max$[esp+244], ebx

; 2758 :     goto REPEATTYPE;

	jmp	$REPEATTYPE$5892
$LN244@match:

; 2759 : 
; 2760 :     case OP_TYPEUPTO:
; 2761 :     case OP_TYPEMINUPTO:
; 2762 :     min = 0;
; 2763 :     max = GET2(ecode, 1);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]

; 2764 :     minimize = *ecode == OP_TYPEMINUPTO;

	xor	ecx, ecx
	xor	ebx, ebx
	cmp	BYTE PTR [edi], 63			; 0000003fH
	sete	cl

; 2765 :     ecode += 3;

	add	edi, 3
	mov	al, BYTE PTR [edi-1]
	mov	DWORD PTR _minimize$[esp+244], ecx
	mov	DWORD PTR _max$[esp+244], eax

; 2766 :     goto REPEATTYPE;

	jmp	$REPEATTYPE$5892
$LN243@match:

; 2767 : 
; 2768 :     case OP_TYPEPOSSTAR:
; 2769 :     possessive = TRUE;
; 2770 :     min = 0;

	xor	ebx, ebx
	mov	DWORD PTR _possessive$[esp+244], 1

; 2771 :     max = INT_MAX;
; 2772 :     ecode++;

	add	edi, 1

; 2773 :     goto REPEATTYPE;

	jmp	$LN1428@match
$LN242@match:

; 2774 : 
; 2775 :     case OP_TYPEPOSPLUS:
; 2776 :     possessive = TRUE;

	mov	ebx, 1
	mov	DWORD PTR _possessive$[esp+244], ebx

; 2777 :     min = 1;
; 2778 :     max = INT_MAX;
; 2779 :     ecode++;

	add	edi, ebx

; 2780 :     goto REPEATTYPE;

	jmp	SHORT $LN1428@match
$LN241@match:

; 2781 : 
; 2782 :     case OP_TYPEPOSQUERY:
; 2783 :     possessive = TRUE;

	mov	eax, 1

; 2784 :     min = 0;

	xor	ebx, ebx
	mov	DWORD PTR _possessive$[esp+244], eax

; 2785 :     max = 1;

	mov	DWORD PTR _max$[esp+244], eax

; 2786 :     ecode++;

	add	edi, eax

; 2787 :     goto REPEATTYPE;

	jmp	SHORT $REPEATTYPE$5892
$LN240@match:

; 2788 : 
; 2789 :     case OP_TYPEPOSUPTO:
; 2790 :     possessive = TRUE;
; 2791 :     min = 0;
; 2792 :     max = GET2(ecode, 1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	xor	ebx, ebx
	mov	DWORD PTR _possessive$[esp+244], 1

; 2793 :     ecode += 3;

	add	edi, 3
	mov	dl, BYTE PTR [edi-1]
	mov	DWORD PTR _max$[esp+244], edx

; 2794 :     goto REPEATTYPE;

	jmp	SHORT $REPEATTYPE$5892
$LN239@match:

; 2795 : 
; 2796 :     case OP_TYPESTAR:
; 2797 :     case OP_TYPEMINSTAR:
; 2798 :     case OP_TYPEPLUS:
; 2799 :     case OP_TYPEMINPLUS:
; 2800 :     case OP_TYPEQUERY:
; 2801 :     case OP_TYPEMINQUERY:
; 2802 :     c = *ecode++ - OP_TYPESTAR;

	movzx	eax, BYTE PTR [edi]

; 2803 :     minimize = (c & 1) != 0;
; 2804 :     min = rep_min[c];                 /* Pick up values from tables; */

	movsx	ebx, BYTE PTR _rep_min[eax-56]
	sub	eax, 56					; 00000038H
	mov	ecx, eax

; 2805 :     max = rep_max[c];                 /* zero for max => infinity */

	movsx	eax, BYTE PTR _rep_max[eax]
	and	ecx, 1
	add	edi, 1

; 2806 :     if (max == 0) max = INT_MAX;

	test	eax, eax
	mov	DWORD PTR _minimize$[esp+244], ecx
	mov	DWORD PTR _max$[esp+244], eax
	jne	SHORT $REPEATTYPE$5892
$LN1428@match:
	mov	DWORD PTR _max$[esp+244], 2147483647	; 7fffffffH
$REPEATTYPE$5892:

; 2807 : 
; 2808 :     /* Common code for all repeated single character type matches. Note that
; 2809 :     in UTF-8 mode, '.' matches a character of any length, but for the other
; 2810 :     character types, the valid characters are all one-byte long. */
; 2811 : 
; 2812 :     REPEATTYPE:
; 2813 :     ctype = *ecode++;      /* Code for the character type */
; 2814 : 
; 2815 : #ifdef SUPPORT_UCP
; 2816 :     if (ctype == OP_PROP || ctype == OP_NOTPROP)
; 2817 :       {
; 2818 :       prop_fail_result = ctype == OP_NOTPROP;
; 2819 :       prop_type = *ecode++;
; 2820 :       prop_value = *ecode++;
; 2821 :       }
; 2822 :     else prop_type = -1;
; 2823 : #endif
; 2824 : 
; 2825 :     /* First, ensure the minimum number of matches are present. Use inline
; 2826 :     code for maximizing the speed, and do the type test once at the start
; 2827 :     (i.e. keep it out of the loop). Also we can test that there are at least
; 2828 :     the minimum number of bytes before we start. This isn't as effective in
; 2829 :     UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
; 2830 :     is tidier. Also separate the UCP code, which can be the same for both UTF-8
; 2831 :     and single-bytes. */
; 2832 : 
; 2833 :     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);

	mov	edx, DWORD PTR [ebp+88]
	movzx	eax, BYTE PTR [edi]
	mov	ecx, edx
	sub	ecx, esi
	add	edi, 1
	cmp	ebx, ecx
	mov	DWORD PTR _ctype$[esp+244], eax
	jg	$LN645@match

; 2834 :     if (min > 0)

	test	ebx, ebx
	jle	$LN148@match

; 2835 :       {
; 2836 : #ifdef SUPPORT_UCP
; 2837 :       if (prop_type >= 0)
; 2838 :         {
; 2839 :         switch(prop_type)
; 2840 :           {
; 2841 :           case PT_ANY:
; 2842 :           if (prop_fail_result) RRETURN(MATCH_NOMATCH);
; 2843 :           for (i = 1; i <= min; i++)
; 2844 :             {
; 2845 :             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2846 :             GETCHARINCTEST(c, eptr);
; 2847 :             }
; 2848 :           break;
; 2849 : 
; 2850 :           case PT_LAMP:
; 2851 :           for (i = 1; i <= min; i++)
; 2852 :             {
; 2853 :             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2854 :             GETCHARINCTEST(c, eptr);
; 2855 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 2856 :             if ((prop_chartype == ucp_Lu ||
; 2857 :                  prop_chartype == ucp_Ll ||
; 2858 :                  prop_chartype == ucp_Lt) == prop_fail_result)
; 2859 :               RRETURN(MATCH_NOMATCH);
; 2860 :             }
; 2861 :           break;
; 2862 : 
; 2863 :           case PT_GC:
; 2864 :           for (i = 1; i <= min; i++)
; 2865 :             {
; 2866 :             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2867 :             GETCHARINCTEST(c, eptr);
; 2868 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 2869 :             if ((prop_category == prop_value) == prop_fail_result)
; 2870 :               RRETURN(MATCH_NOMATCH);
; 2871 :             }
; 2872 :           break;
; 2873 : 
; 2874 :           case PT_PC:
; 2875 :           for (i = 1; i <= min; i++)
; 2876 :             {
; 2877 :             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2878 :             GETCHARINCTEST(c, eptr);
; 2879 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 2880 :             if ((prop_chartype == prop_value) == prop_fail_result)
; 2881 :               RRETURN(MATCH_NOMATCH);
; 2882 :             }
; 2883 :           break;
; 2884 : 
; 2885 :           case PT_SC:
; 2886 :           for (i = 1; i <= min; i++)
; 2887 :             {
; 2888 :             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2889 :             GETCHARINCTEST(c, eptr);
; 2890 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 2891 :             if ((prop_script == prop_value) == prop_fail_result)
; 2892 :               RRETURN(MATCH_NOMATCH);
; 2893 :             }
; 2894 :           break;
; 2895 : 
; 2896 :           default:
; 2897 :           RRETURN(PCRE_ERROR_INTERNAL);
; 2898 :           }
; 2899 :         }
; 2900 : 
; 2901 :       /* Match extended Unicode sequences. We will get here only if the
; 2902 :       support is in the binary; otherwise a compile-time error occurs. */
; 2903 : 
; 2904 :       else if (ctype == OP_EXTUNI)
; 2905 :         {
; 2906 :         for (i = 1; i <= min; i++)
; 2907 :           {
; 2908 :           GETCHARINCTEST(c, eptr);
; 2909 :           prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 2910 :           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
; 2911 :           while (eptr < md->end_subject)
; 2912 :             {
; 2913 :             int len = 1;
; 2914 :             if (!utf8) c = *eptr; else
; 2915 :               {
; 2916 :               GETCHARLEN(c, eptr, len);
; 2917 :               }
; 2918 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 2919 :             if (prop_category != ucp_M) break;
; 2920 :             eptr += len;
; 2921 :             }
; 2922 :           }
; 2923 :         }
; 2924 : 
; 2925 :       else
; 2926 : #endif     /* SUPPORT_UCP */
; 2927 : 
; 2928 : /* Handle all other cases when the coding is UTF-8 */
; 2929 : 
; 2930 : #ifdef SUPPORT_UTF8
; 2931 :       if (utf8) switch(ctype)
; 2932 :         {
; 2933 :         case OP_ANY:
; 2934 :         for (i = 1; i <= min; i++)
; 2935 :           {
; 2936 :           if (eptr >= md->end_subject ||
; 2937 :                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
; 2938 :             RRETURN(MATCH_NOMATCH);
; 2939 :           eptr++;
; 2940 :           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
; 2941 :           }
; 2942 :         break;
; 2943 : 
; 2944 :         case OP_ANYBYTE:
; 2945 :         eptr += min;
; 2946 :         break;
; 2947 : 
; 2948 :         case OP_ANYNL:
; 2949 :         for (i = 1; i <= min; i++)
; 2950 :           {
; 2951 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2952 :           GETCHARINC(c, eptr);
; 2953 :           switch(c)
; 2954 :             {
; 2955 :             default: RRETURN(MATCH_NOMATCH);
; 2956 :             case 0x000d:
; 2957 :             if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
; 2958 :             break;
; 2959 : 
; 2960 :             case 0x000a:
; 2961 :             break;
; 2962 : 
; 2963 :             case 0x000b:
; 2964 :             case 0x000c:
; 2965 :             case 0x0085:
; 2966 :             case 0x2028:
; 2967 :             case 0x2029:
; 2968 :             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
; 2969 :             break;
; 2970 :             }
; 2971 :           }
; 2972 :         break;
; 2973 : 
; 2974 :         case OP_NOT_HSPACE:
; 2975 :         for (i = 1; i <= min; i++)
; 2976 :           {
; 2977 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 2978 :           GETCHARINC(c, eptr);
; 2979 :           switch(c)
; 2980 :             {
; 2981 :             default: break;
; 2982 :             case 0x09:      /* HT */
; 2983 :             case 0x20:      /* SPACE */
; 2984 :             case 0xa0:      /* NBSP */
; 2985 :             case 0x1680:    /* OGHAM SPACE MARK */
; 2986 :             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 2987 :             case 0x2000:    /* EN QUAD */
; 2988 :             case 0x2001:    /* EM QUAD */
; 2989 :             case 0x2002:    /* EN SPACE */
; 2990 :             case 0x2003:    /* EM SPACE */
; 2991 :             case 0x2004:    /* THREE-PER-EM SPACE */
; 2992 :             case 0x2005:    /* FOUR-PER-EM SPACE */
; 2993 :             case 0x2006:    /* SIX-PER-EM SPACE */
; 2994 :             case 0x2007:    /* FIGURE SPACE */
; 2995 :             case 0x2008:    /* PUNCTUATION SPACE */
; 2996 :             case 0x2009:    /* THIN SPACE */
; 2997 :             case 0x200A:    /* HAIR SPACE */
; 2998 :             case 0x202f:    /* NARROW NO-BREAK SPACE */
; 2999 :             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3000 :             case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3001 :             RRETURN(MATCH_NOMATCH);
; 3002 :             }
; 3003 :           }
; 3004 :         break;
; 3005 : 
; 3006 :         case OP_HSPACE:
; 3007 :         for (i = 1; i <= min; i++)
; 3008 :           {
; 3009 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3010 :           GETCHARINC(c, eptr);
; 3011 :           switch(c)
; 3012 :             {
; 3013 :             default: RRETURN(MATCH_NOMATCH);
; 3014 :             case 0x09:      /* HT */
; 3015 :             case 0x20:      /* SPACE */
; 3016 :             case 0xa0:      /* NBSP */
; 3017 :             case 0x1680:    /* OGHAM SPACE MARK */
; 3018 :             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 3019 :             case 0x2000:    /* EN QUAD */
; 3020 :             case 0x2001:    /* EM QUAD */
; 3021 :             case 0x2002:    /* EN SPACE */
; 3022 :             case 0x2003:    /* EM SPACE */
; 3023 :             case 0x2004:    /* THREE-PER-EM SPACE */
; 3024 :             case 0x2005:    /* FOUR-PER-EM SPACE */
; 3025 :             case 0x2006:    /* SIX-PER-EM SPACE */
; 3026 :             case 0x2007:    /* FIGURE SPACE */
; 3027 :             case 0x2008:    /* PUNCTUATION SPACE */
; 3028 :             case 0x2009:    /* THIN SPACE */
; 3029 :             case 0x200A:    /* HAIR SPACE */
; 3030 :             case 0x202f:    /* NARROW NO-BREAK SPACE */
; 3031 :             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3032 :             case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3033 :             break;
; 3034 :             }
; 3035 :           }
; 3036 :         break;
; 3037 : 
; 3038 :         case OP_NOT_VSPACE:
; 3039 :         for (i = 1; i <= min; i++)
; 3040 :           {
; 3041 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3042 :           GETCHARINC(c, eptr);
; 3043 :           switch(c)
; 3044 :             {
; 3045 :             default: break;
; 3046 :             case 0x0a:      /* LF */
; 3047 :             case 0x0b:      /* VT */
; 3048 :             case 0x0c:      /* FF */
; 3049 :             case 0x0d:      /* CR */
; 3050 :             case 0x85:      /* NEL */
; 3051 :             case 0x2028:    /* LINE SEPARATOR */
; 3052 :             case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3053 :             RRETURN(MATCH_NOMATCH);
; 3054 :             }
; 3055 :           }
; 3056 :         break;
; 3057 : 
; 3058 :         case OP_VSPACE:
; 3059 :         for (i = 1; i <= min; i++)
; 3060 :           {
; 3061 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3062 :           GETCHARINC(c, eptr);
; 3063 :           switch(c)
; 3064 :             {
; 3065 :             default: RRETURN(MATCH_NOMATCH);
; 3066 :             case 0x0a:      /* LF */
; 3067 :             case 0x0b:      /* VT */
; 3068 :             case 0x0c:      /* FF */
; 3069 :             case 0x0d:      /* CR */
; 3070 :             case 0x85:      /* NEL */
; 3071 :             case 0x2028:    /* LINE SEPARATOR */
; 3072 :             case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3073 :             break;
; 3074 :             }
; 3075 :           }
; 3076 :         break;
; 3077 : 
; 3078 :         case OP_NOT_DIGIT:
; 3079 :         for (i = 1; i <= min; i++)
; 3080 :           {
; 3081 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3082 :           GETCHARINC(c, eptr);
; 3083 :           if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
; 3084 :             RRETURN(MATCH_NOMATCH);
; 3085 :           }
; 3086 :         break;
; 3087 : 
; 3088 :         case OP_DIGIT:
; 3089 :         for (i = 1; i <= min; i++)
; 3090 :           {
; 3091 :           if (eptr >= md->end_subject ||
; 3092 :              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
; 3093 :             RRETURN(MATCH_NOMATCH);
; 3094 :           /* No need to skip more bytes - we know it's a 1-byte character */
; 3095 :           }
; 3096 :         break;
; 3097 : 
; 3098 :         case OP_NOT_WHITESPACE:
; 3099 :         for (i = 1; i <= min; i++)
; 3100 :           {
; 3101 :           if (eptr >= md->end_subject ||
; 3102 :              (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
; 3103 :             RRETURN(MATCH_NOMATCH);
; 3104 :           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
; 3105 :           }
; 3106 :         break;
; 3107 : 
; 3108 :         case OP_WHITESPACE:
; 3109 :         for (i = 1; i <= min; i++)
; 3110 :           {
; 3111 :           if (eptr >= md->end_subject ||
; 3112 :              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
; 3113 :             RRETURN(MATCH_NOMATCH);
; 3114 :           /* No need to skip more bytes - we know it's a 1-byte character */
; 3115 :           }
; 3116 :         break;
; 3117 : 
; 3118 :         case OP_NOT_WORDCHAR:
; 3119 :         for (i = 1; i <= min; i++)
; 3120 :           {
; 3121 :           if (eptr >= md->end_subject ||
; 3122 :              (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
; 3123 :             RRETURN(MATCH_NOMATCH);
; 3124 :           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
; 3125 :           }
; 3126 :         break;
; 3127 : 
; 3128 :         case OP_WORDCHAR:
; 3129 :         for (i = 1; i <= min; i++)
; 3130 :           {
; 3131 :           if (eptr >= md->end_subject ||
; 3132 :              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
; 3133 :             RRETURN(MATCH_NOMATCH);
; 3134 :           /* No need to skip more bytes - we know it's a 1-byte character */
; 3135 :           }
; 3136 :         break;
; 3137 : 
; 3138 :         default:
; 3139 :         RRETURN(PCRE_ERROR_INTERNAL);
; 3140 :         }  /* End switch(ctype) */
; 3141 : 
; 3142 :       else
; 3143 : #endif     /* SUPPORT_UTF8 */
; 3144 : 
; 3145 :       /* Code for the non-UTF-8 case for minimum matching of operators other
; 3146 :       than OP_PROP and OP_NOTPROP. We can assume that there are the minimum
; 3147 :       number of bytes present, as this was tested above. */
; 3148 : 
; 3149 :       switch(ctype)

	add	eax, -6					; fffffffaH
	cmp	eax, 14					; 0000000eH
	ja	$LN146@match
	jmp	DWORD PTR $LN1435@match[eax*4]
$LN233@match:

; 3150 :         {
; 3151 :         case OP_ANY:
; 3152 :         if ((ims & PCRE_DOTALL) == 0)

	test	BYTE PTR _ims$[esp+240], 4
	jne	$LN232@match

; 3153 :           {
; 3154 :           for (i = 1; i <= min; i++)

	cmp	ebx, 1
	mov	DWORD PTR _i$[esp+244], 1
	jl	$LN148@match
	npad	5
$LL231@match:

; 3155 :             {
; 3156 :             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN724@match
	mov	eax, DWORD PTR [ebp+88]
	cmp	esi, eax
	jae	SHORT $LN720@match
	push	0
	lea	edx, DWORD PTR [ebp+28]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	$LN645@match
	jmp	SHORT $LN720@match
$LN724@match:
	mov	eax, DWORD PTR [ebp+28]
	mov	ecx, DWORD PTR [ebp+88]
	sub	ecx, eax
	cmp	esi, ecx
	ja	SHORT $LN720@match
	mov	dl, BYTE PTR [esi]
	cmp	dl, BYTE PTR [ebp+32]
	jne	SHORT $LN720@match
	cmp	eax, 1
	je	$LN645@match
	mov	al, BYTE PTR [esi+1]
	cmp	al, BYTE PTR [ebp+33]
	je	$LN645@match
$LN720@match:

; 3153 :           {
; 3154 :           for (i = 1; i <= min; i++)

	mov	eax, DWORD PTR _i$[esp+244]
	add	eax, 1

; 3157 :             eptr++;

	add	esi, 1
	cmp	eax, ebx
	mov	DWORD PTR _i$[esp+244], eax
	jle	SHORT $LL231@match

; 3158 :             }
; 3159 :           }
; 3160 :         else eptr += min;

	jmp	$LN148@match
$LN232@match:
	add	esi, ebx

; 3161 :         break;

	jmp	$LN148@match
$LN225@match:

; 3162 : 
; 3163 :         case OP_ANYBYTE:
; 3164 :         eptr += min;
; 3165 :         break;
; 3166 : 
; 3167 :         /* Because of the CRLF case, we can't assume the minimum number of
; 3168 :         bytes are present in this case. */
; 3169 : 
; 3170 :         case OP_ANYNL:
; 3171 :         for (i = 1; i <= min; i++)

	mov	ecx, 1
	cmp	ebx, ecx
	jl	$LN148@match
	npad	4
$LL224@match:

; 3172 :           {
; 3173 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, edx
	jae	$LN645@match

; 3174 :           switch(*eptr++)

	movzx	eax, BYTE PTR [esi]
	sub	eax, 10					; 0000000aH
	add	esi, 1
	cmp	eax, 123				; 0000007bH
	ja	$LN645@match
	movzx	eax, BYTE PTR $LN1245@match[eax]
	jmp	DWORD PTR $LN1436@match[eax*4]
$LN217@match:

; 3175 :             {
; 3176 :             default: RRETURN(MATCH_NOMATCH);
; 3177 :             case 0x000d:
; 3178 :             if (eptr < md->end_subject && *eptr == 0x0a) eptr++;

	cmp	esi, edx
	jae	SHORT $LN223@match
	cmp	BYTE PTR [esi], 10			; 0000000aH
	jne	SHORT $LN223@match
	add	esi, 1

; 3179 :             break;

	jmp	SHORT $LN223@match
$LN214@match:

; 3180 :             case 0x000a:
; 3181 :             break;
; 3182 : 
; 3183 :             case 0x000b:
; 3184 :             case 0x000c:
; 3185 :             case 0x0085:
; 3186 :             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);

	cmp	DWORD PTR [ebp+76], 0
	jne	$LN645@match
$LN223@match:

; 3162 : 
; 3163 :         case OP_ANYBYTE:
; 3164 :         eptr += min;
; 3165 :         break;
; 3166 : 
; 3167 :         /* Because of the CRLF case, we can't assume the minimum number of
; 3168 :         bytes are present in this case. */
; 3169 : 
; 3170 :         case OP_ANYNL:
; 3171 :         for (i = 1; i <= min; i++)

	add	ecx, 1
	cmp	ecx, ebx
	jle	SHORT $LL224@match

; 3187 :             break;
; 3188 :             }
; 3189 :           }
; 3190 :         break;

	jmp	$LN148@match
$LN212@match:

; 3191 : 
; 3192 :         case OP_NOT_HSPACE:
; 3193 :         for (i = 1; i <= min; i++)

	mov	ecx, 1
	cmp	ebx, ecx
	jl	$LN148@match
	npad	7
$LL211@match:

; 3194 :           {
; 3195 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, edx
	jae	$LN645@match

; 3196 :           switch(*eptr++)

	movzx	eax, BYTE PTR [esi]
	add	esi, 1
	cmp	eax, 9
	je	$LN645@match
	cmp	eax, 32					; 00000020H
	je	$LN645@match
	cmp	eax, 160				; 000000a0H
	je	$LN645@match
	add	ecx, 1
	cmp	ecx, ebx
	jle	SHORT $LL211@match

; 3197 :             {
; 3198 :             default: break;
; 3199 :             case 0x09:      /* HT */
; 3200 :             case 0x20:      /* SPACE */
; 3201 :             case 0xa0:      /* NBSP */
; 3202 :             RRETURN(MATCH_NOMATCH);
; 3203 :             }
; 3204 :           }
; 3205 :         break;

	jmp	$LN148@match
$LN203@match:

; 3206 : 
; 3207 :         case OP_HSPACE:
; 3208 :         for (i = 1; i <= min; i++)

	mov	ecx, 1
	cmp	ebx, ecx
	jl	$LN148@match
$LL202@match:

; 3209 :           {
; 3210 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, edx
	jae	$LN645@match

; 3211 :           switch(*eptr++)

	movzx	eax, BYTE PTR [esi]
	add	esi, 1
	cmp	eax, 9
	je	SHORT $LN201@match
	cmp	eax, 32					; 00000020H
	je	SHORT $LN201@match
	cmp	eax, 160				; 000000a0H
	jne	$LN645@match
$LN201@match:

; 3206 : 
; 3207 :         case OP_HSPACE:
; 3208 :         for (i = 1; i <= min; i++)

	add	ecx, 1
	cmp	ecx, ebx
	jle	SHORT $LL202@match

; 3212 :             {
; 3213 :             default: RRETURN(MATCH_NOMATCH);
; 3214 :             case 0x09:      /* HT */
; 3215 :             case 0x20:      /* SPACE */
; 3216 :             case 0xa0:      /* NBSP */
; 3217 :             break;
; 3218 :             }
; 3219 :           }
; 3220 :         break;

	jmp	$LN148@match
$LN194@match:

; 3221 : 
; 3222 :         case OP_NOT_VSPACE:
; 3223 :         for (i = 1; i <= min; i++)

	mov	ecx, 1
	cmp	ebx, ecx
	jl	$LN148@match
$LL193@match:

; 3224 :           {
; 3225 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, edx
	jae	$LN645@match

; 3226 :           switch(*eptr++)

	movzx	eax, BYTE PTR [esi]
	add	esi, 1
	cmp	eax, 10					; 0000000aH
	jl	SHORT $LN192@match
	cmp	eax, 13					; 0000000dH
	jle	$LN645@match
	cmp	eax, 133				; 00000085H
	je	$LN645@match
$LN192@match:

; 3221 : 
; 3222 :         case OP_NOT_VSPACE:
; 3223 :         for (i = 1; i <= min; i++)

	add	ecx, 1
	cmp	ecx, ebx
	jle	SHORT $LL193@match

; 3227 :             {
; 3228 :             default: break;
; 3229 :             case 0x0a:      /* LF */
; 3230 :             case 0x0b:      /* VT */
; 3231 :             case 0x0c:      /* FF */
; 3232 :             case 0x0d:      /* CR */
; 3233 :             case 0x85:      /* NEL */
; 3234 :             RRETURN(MATCH_NOMATCH);
; 3235 :             }
; 3236 :           }
; 3237 :         break;

	jmp	$LN148@match
$LN185@match:

; 3238 : 
; 3239 :         case OP_VSPACE:
; 3240 :         for (i = 1; i <= min; i++)

	mov	ecx, 1
	cmp	ebx, ecx
	jl	$LN148@match
$LL184@match:

; 3241 :           {
; 3242 :           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);

	cmp	esi, edx
	jae	$LN645@match

; 3243 :           switch(*eptr++)

	movzx	eax, BYTE PTR [esi]
	add	esi, 1
	cmp	eax, 10					; 0000000aH
	jl	$LN645@match
	cmp	eax, 13					; 0000000dH
	jle	SHORT $LN183@match
	cmp	eax, 133				; 00000085H
	jne	$LN645@match
$LN183@match:

; 3238 : 
; 3239 :         case OP_VSPACE:
; 3240 :         for (i = 1; i <= min; i++)

	add	ecx, 1
	cmp	ecx, ebx
	jle	SHORT $LL184@match

; 3244 :             {
; 3245 :             default: RRETURN(MATCH_NOMATCH);
; 3246 :             case 0x0a:      /* LF */
; 3247 :             case 0x0b:      /* VT */
; 3248 :             case 0x0c:      /* FF */
; 3249 :             case 0x0d:      /* CR */
; 3250 :             case 0x85:      /* NEL */
; 3251 :             break;
; 3252 :             }
; 3253 :           }
; 3254 :         break;

	jmp	$LN148@match
$LN176@match:

; 3255 : 
; 3256 :         case OP_NOT_DIGIT:
; 3257 :         for (i = 1; i <= min; i++)

	mov	eax, 1
	cmp	ebx, eax
	jl	$LN148@match
	mov	ecx, DWORD PTR [ebp+40]
$LL175@match:

; 3258 :           if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	dl, BYTE PTR [edx+ecx]
	and	dl, 4
	add	esi, 1
	test	dl, dl
	jne	$LN645@match
	add	eax, 1
	cmp	eax, ebx
	jle	SHORT $LL175@match

; 3259 :         break;

	jmp	$LN148@match
$LN171@match:

; 3260 : 
; 3261 :         case OP_DIGIT:
; 3262 :         for (i = 1; i <= min; i++)

	mov	eax, 1
	cmp	ebx, eax
	jl	$LN148@match
	mov	ecx, DWORD PTR [ebp+40]
$LL170@match:

; 3263 :           if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	dl, BYTE PTR [edx+ecx]
	and	dl, 4
	add	esi, 1
	test	dl, dl
	je	$LN645@match
	add	eax, 1
	cmp	eax, ebx
	jle	SHORT $LL170@match

; 3264 :         break;

	jmp	$LN148@match
$LN166@match:

; 3265 : 
; 3266 :         case OP_NOT_WHITESPACE:
; 3267 :         for (i = 1; i <= min; i++)

	mov	eax, 1
	cmp	ebx, eax
	jl	$LN148@match
	mov	ecx, DWORD PTR [ebp+40]
$LL165@match:

; 3268 :           if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	dl, BYTE PTR [edx+ecx]
	and	dl, 1
	add	esi, 1
	test	dl, dl
	jne	$LN645@match
	add	eax, 1
	cmp	eax, ebx
	jle	SHORT $LL165@match

; 3269 :         break;

	jmp	$LN148@match
$LN161@match:

; 3270 : 
; 3271 :         case OP_WHITESPACE:
; 3272 :         for (i = 1; i <= min; i++)

	mov	eax, 1
	cmp	ebx, eax
	jl	$LN148@match
	mov	ecx, DWORD PTR [ebp+40]
$LL160@match:

; 3273 :           if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);

	movzx	edx, BYTE PTR [esi]
	mov	dl, BYTE PTR [edx+ecx]
	and	dl, 1
	add	esi, 1
	test	dl, dl
	je	$LN645@match
	add	eax, 1
	cmp	eax, ebx
	jle	SHORT $LL160@match

; 3274 :         break;

	jmp	$LN148@match
$LN156@match:

; 3275 : 
; 3276 :         case OP_NOT_WORDCHAR:
; 3277 :         for (i = 1; i <= min; i++)

	mov	eax, 1
	cmp	ebx, eax
	jl	SHORT $LN148@match
	mov	ecx, DWORD PTR [ebp+40]
	npad	1
$LL155@match:

; 3278 :           if ((md->ctypes[*eptr++] & ctype_word) != 0)

	movzx	edx, BYTE PTR [esi]
	mov	dl, BYTE PTR [edx+ecx]
	and	dl, 16					; 00000010H
	add	esi, 1
	test	dl, dl
	jne	$LN645@match
	add	eax, 1
	cmp	eax, ebx
	jle	SHORT $LL155@match

; 3279 :             RRETURN(MATCH_NOMATCH);
; 3280 :         break;

	jmp	SHORT $LN148@match
$LN151@match:

; 3281 : 
; 3282 :         case OP_WORDCHAR:
; 3283 :         for (i = 1; i <= min; i++)

	mov	eax, 1
	cmp	ebx, eax
	jl	SHORT $LN148@match
	mov	ecx, DWORD PTR [ebp+40]
	npad	7
$LL150@match:

; 3284 :           if ((md->ctypes[*eptr++] & ctype_word) == 0)

	movzx	edx, BYTE PTR [esi]
	mov	dl, BYTE PTR [edx+ecx]
	and	dl, 16					; 00000010H
	add	esi, 1
	test	dl, dl
	je	$LN645@match
	add	eax, 1
	cmp	eax, ebx
	jle	SHORT $LL150@match
$LN148@match:

; 3290 :         }
; 3291 :       }
; 3292 : 
; 3293 :     /* If min = max, continue at the same level without recursing */
; 3294 : 
; 3295 :     if (min == max) continue;

	cmp	ebx, DWORD PTR _max$[esp+244]
	je	$LL650@match

; 3296 : 
; 3297 :     /* If minimizing, we have to test the rest of the pattern before each
; 3298 :     subsequent match. Again, separate the UTF-8 case for speed, and also
; 3299 :     separate the UCP cases. */
; 3300 : 
; 3301 :     if (minimize)

	cmp	DWORD PTR _minimize$[esp+244], 0
	jne	$LN939@match

; 3679 :             break;
; 3680 : 
; 3681 :             default:
; 3682 :             RRETURN(PCRE_ERROR_INTERNAL);
; 3683 :             }
; 3684 :           }
; 3685 :         }
; 3686 :       /* Control never gets here */
; 3687 :       }
; 3688 : 
; 3689 :     /* If maximizing, it is worth using inline code for speed, doing the type
; 3690 :     test once at the start (i.e. keep it out of the loop). Again, keep the
; 3691 :     UTF-8 and UCP stuff separate. */
; 3692 : 
; 3693 :     else
; 3694 :       {
; 3695 :       pp = eptr;  /* Remember where we started */
; 3696 : 
; 3697 : #ifdef SUPPORT_UCP
; 3698 :       if (prop_type >= 0)
; 3699 :         {
; 3700 :         switch(prop_type)
; 3701 :           {
; 3702 :           case PT_ANY:
; 3703 :           for (i = min; i < max; i++)
; 3704 :             {
; 3705 :             int len = 1;
; 3706 :             if (eptr >= md->end_subject) break;
; 3707 :             GETCHARLEN(c, eptr, len);
; 3708 :             if (prop_fail_result) break;
; 3709 :             eptr+= len;
; 3710 :             }
; 3711 :           break;
; 3712 : 
; 3713 :           case PT_LAMP:
; 3714 :           for (i = min; i < max; i++)
; 3715 :             {
; 3716 :             int len = 1;
; 3717 :             if (eptr >= md->end_subject) break;
; 3718 :             GETCHARLEN(c, eptr, len);
; 3719 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3720 :             if ((prop_chartype == ucp_Lu ||
; 3721 :                  prop_chartype == ucp_Ll ||
; 3722 :                  prop_chartype == ucp_Lt) == prop_fail_result)
; 3723 :               break;
; 3724 :             eptr+= len;
; 3725 :             }
; 3726 :           break;
; 3727 : 
; 3728 :           case PT_GC:
; 3729 :           for (i = min; i < max; i++)
; 3730 :             {
; 3731 :             int len = 1;
; 3732 :             if (eptr >= md->end_subject) break;
; 3733 :             GETCHARLEN(c, eptr, len);
; 3734 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3735 :             if ((prop_category == prop_value) == prop_fail_result)
; 3736 :               break;
; 3737 :             eptr+= len;
; 3738 :             }
; 3739 :           break;
; 3740 : 
; 3741 :           case PT_PC:
; 3742 :           for (i = min; i < max; i++)
; 3743 :             {
; 3744 :             int len = 1;
; 3745 :             if (eptr >= md->end_subject) break;
; 3746 :             GETCHARLEN(c, eptr, len);
; 3747 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3748 :             if ((prop_chartype == prop_value) == prop_fail_result)
; 3749 :               break;
; 3750 :             eptr+= len;
; 3751 :             }
; 3752 :           break;
; 3753 : 
; 3754 :           case PT_SC:
; 3755 :           for (i = min; i < max; i++)
; 3756 :             {
; 3757 :             int len = 1;
; 3758 :             if (eptr >= md->end_subject) break;
; 3759 :             GETCHARLEN(c, eptr, len);
; 3760 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3761 :             if ((prop_script == prop_value) == prop_fail_result)
; 3762 :               break;
; 3763 :             eptr+= len;
; 3764 :             }
; 3765 :           break;
; 3766 :           }
; 3767 : 
; 3768 :         /* eptr is now past the end of the maximum run */
; 3769 : 
; 3770 :         if (possessive) continue;
; 3771 :         for(;;)
; 3772 :           {
; 3773 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
; 3774 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3775 :           if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 3776 :           if (utf8) BACKCHAR(eptr);
; 3777 :           }
; 3778 :         }
; 3779 : 
; 3780 :       /* Match extended Unicode sequences. We will get here only if the
; 3781 :       support is in the binary; otherwise a compile-time error occurs. */
; 3782 : 
; 3783 :       else if (ctype == OP_EXTUNI)
; 3784 :         {
; 3785 :         for (i = min; i < max; i++)
; 3786 :           {
; 3787 :           if (eptr >= md->end_subject) break;
; 3788 :           GETCHARINCTEST(c, eptr);
; 3789 :           prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3790 :           if (prop_category == ucp_M) break;
; 3791 :           while (eptr < md->end_subject)
; 3792 :             {
; 3793 :             int len = 1;
; 3794 :             if (!utf8) c = *eptr; else
; 3795 :               {
; 3796 :               GETCHARLEN(c, eptr, len);
; 3797 :               }
; 3798 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3799 :             if (prop_category != ucp_M) break;
; 3800 :             eptr += len;
; 3801 :             }
; 3802 :           }
; 3803 : 
; 3804 :         /* eptr is now past the end of the maximum run */
; 3805 : 
; 3806 :         if (possessive) continue;
; 3807 :         for(;;)
; 3808 :           {
; 3809 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
; 3810 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3811 :           if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 3812 :           for (;;)                        /* Move back over one extended */
; 3813 :             {
; 3814 :             int len = 1;
; 3815 :             if (!utf8) c = *eptr; else
; 3816 :               {
; 3817 :               BACKCHAR(eptr);
; 3818 :               GETCHARLEN(c, eptr, len);
; 3819 :               }
; 3820 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3821 :             if (prop_category != ucp_M) break;
; 3822 :             eptr--;
; 3823 :             }
; 3824 :           }
; 3825 :         }
; 3826 : 
; 3827 :       else
; 3828 : #endif   /* SUPPORT_UCP */
; 3829 : 
; 3830 : #ifdef SUPPORT_UTF8
; 3831 :       /* UTF-8 mode */
; 3832 : 
; 3833 :       if (utf8)
; 3834 :         {
; 3835 :         switch(ctype)
; 3836 :           {
; 3837 :           case OP_ANY:
; 3838 :           if (max < INT_MAX)
; 3839 :             {
; 3840 :             if ((ims & PCRE_DOTALL) == 0)
; 3841 :               {
; 3842 :               for (i = min; i < max; i++)
; 3843 :                 {
; 3844 :                 if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
; 3845 :                 eptr++;
; 3846 :                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
; 3847 :                 }
; 3848 :               }
; 3849 :             else
; 3850 :               {
; 3851 :               for (i = min; i < max; i++)
; 3852 :                 {
; 3853 :                 if (eptr >= md->end_subject) break;
; 3854 :                 eptr++;
; 3855 :                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
; 3856 :                 }
; 3857 :               }
; 3858 :             }
; 3859 : 
; 3860 :           /* Handle unlimited UTF-8 repeat */
; 3861 : 
; 3862 :           else
; 3863 :             {
; 3864 :             if ((ims & PCRE_DOTALL) == 0)
; 3865 :               {
; 3866 :               for (i = min; i < max; i++)
; 3867 :                 {
; 3868 :                 if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
; 3869 :                 eptr++;
; 3870 :                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
; 3871 :                 }
; 3872 :               }
; 3873 :             else
; 3874 :               {
; 3875 :               eptr = md->end_subject;
; 3876 :               }
; 3877 :             }
; 3878 :           break;
; 3879 : 
; 3880 :           /* The byte case is the same as non-UTF8 */
; 3881 : 
; 3882 :           case OP_ANYBYTE:
; 3883 :           c = max - min;
; 3884 :           if (c > (unsigned int)(md->end_subject - eptr))
; 3885 :             c = md->end_subject - eptr;
; 3886 :           eptr += c;
; 3887 :           break;
; 3888 : 
; 3889 :           case OP_ANYNL:
; 3890 :           for (i = min; i < max; i++)
; 3891 :             {
; 3892 :             int len = 1;
; 3893 :             if (eptr >= md->end_subject) break;
; 3894 :             GETCHARLEN(c, eptr, len);
; 3895 :             if (c == 0x000d)
; 3896 :               {
; 3897 :               if (++eptr >= md->end_subject) break;
; 3898 :               if (*eptr == 0x000a) eptr++;
; 3899 :               }
; 3900 :             else
; 3901 :               {
; 3902 :               if (c != 0x000a &&
; 3903 :                   (md->bsr_anycrlf ||
; 3904 :                    (c != 0x000b && c != 0x000c &&
; 3905 :                     c != 0x0085 && c != 0x2028 && c != 0x2029)))
; 3906 :                 break;
; 3907 :               eptr += len;
; 3908 :               }
; 3909 :             }
; 3910 :           break;
; 3911 : 
; 3912 :           case OP_NOT_HSPACE:
; 3913 :           case OP_HSPACE:
; 3914 :           for (i = min; i < max; i++)
; 3915 :             {
; 3916 :             BOOL gotspace;
; 3917 :             int len = 1;
; 3918 :             if (eptr >= md->end_subject) break;
; 3919 :             GETCHARLEN(c, eptr, len);
; 3920 :             switch(c)
; 3921 :               {
; 3922 :               default: gotspace = FALSE; break;
; 3923 :               case 0x09:      /* HT */
; 3924 :               case 0x20:      /* SPACE */
; 3925 :               case 0xa0:      /* NBSP */
; 3926 :               case 0x1680:    /* OGHAM SPACE MARK */
; 3927 :               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 3928 :               case 0x2000:    /* EN QUAD */
; 3929 :               case 0x2001:    /* EM QUAD */
; 3930 :               case 0x2002:    /* EN SPACE */
; 3931 :               case 0x2003:    /* EM SPACE */
; 3932 :               case 0x2004:    /* THREE-PER-EM SPACE */
; 3933 :               case 0x2005:    /* FOUR-PER-EM SPACE */
; 3934 :               case 0x2006:    /* SIX-PER-EM SPACE */
; 3935 :               case 0x2007:    /* FIGURE SPACE */
; 3936 :               case 0x2008:    /* PUNCTUATION SPACE */
; 3937 :               case 0x2009:    /* THIN SPACE */
; 3938 :               case 0x200A:    /* HAIR SPACE */
; 3939 :               case 0x202f:    /* NARROW NO-BREAK SPACE */
; 3940 :               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3941 :               case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3942 :               gotspace = TRUE;
; 3943 :               break;
; 3944 :               }
; 3945 :             if (gotspace == (ctype == OP_NOT_HSPACE)) break;
; 3946 :             eptr += len;
; 3947 :             }
; 3948 :           break;
; 3949 : 
; 3950 :           case OP_NOT_VSPACE:
; 3951 :           case OP_VSPACE:
; 3952 :           for (i = min; i < max; i++)
; 3953 :             {
; 3954 :             BOOL gotspace;
; 3955 :             int len = 1;
; 3956 :             if (eptr >= md->end_subject) break;
; 3957 :             GETCHARLEN(c, eptr, len);
; 3958 :             switch(c)
; 3959 :               {
; 3960 :               default: gotspace = FALSE; break;
; 3961 :               case 0x0a:      /* LF */
; 3962 :               case 0x0b:      /* VT */
; 3963 :               case 0x0c:      /* FF */
; 3964 :               case 0x0d:      /* CR */
; 3965 :               case 0x85:      /* NEL */
; 3966 :               case 0x2028:    /* LINE SEPARATOR */
; 3967 :               case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3968 :               gotspace = TRUE;
; 3969 :               break;
; 3970 :               }
; 3971 :             if (gotspace == (ctype == OP_NOT_VSPACE)) break;
; 3972 :             eptr += len;
; 3973 :             }
; 3974 :           break;
; 3975 : 
; 3976 :           case OP_NOT_DIGIT:
; 3977 :           for (i = min; i < max; i++)
; 3978 :             {
; 3979 :             int len = 1;
; 3980 :             if (eptr >= md->end_subject) break;
; 3981 :             GETCHARLEN(c, eptr, len);
; 3982 :             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
; 3983 :             eptr+= len;
; 3984 :             }
; 3985 :           break;
; 3986 : 
; 3987 :           case OP_DIGIT:
; 3988 :           for (i = min; i < max; i++)
; 3989 :             {
; 3990 :             int len = 1;
; 3991 :             if (eptr >= md->end_subject) break;
; 3992 :             GETCHARLEN(c, eptr, len);
; 3993 :             if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
; 3994 :             eptr+= len;
; 3995 :             }
; 3996 :           break;
; 3997 : 
; 3998 :           case OP_NOT_WHITESPACE:
; 3999 :           for (i = min; i < max; i++)
; 4000 :             {
; 4001 :             int len = 1;
; 4002 :             if (eptr >= md->end_subject) break;
; 4003 :             GETCHARLEN(c, eptr, len);
; 4004 :             if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
; 4005 :             eptr+= len;
; 4006 :             }
; 4007 :           break;
; 4008 : 
; 4009 :           case OP_WHITESPACE:
; 4010 :           for (i = min; i < max; i++)
; 4011 :             {
; 4012 :             int len = 1;
; 4013 :             if (eptr >= md->end_subject) break;
; 4014 :             GETCHARLEN(c, eptr, len);
; 4015 :             if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
; 4016 :             eptr+= len;
; 4017 :             }
; 4018 :           break;
; 4019 : 
; 4020 :           case OP_NOT_WORDCHAR:
; 4021 :           for (i = min; i < max; i++)
; 4022 :             {
; 4023 :             int len = 1;
; 4024 :             if (eptr >= md->end_subject) break;
; 4025 :             GETCHARLEN(c, eptr, len);
; 4026 :             if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
; 4027 :             eptr+= len;
; 4028 :             }
; 4029 :           break;
; 4030 : 
; 4031 :           case OP_WORDCHAR:
; 4032 :           for (i = min; i < max; i++)
; 4033 :             {
; 4034 :             int len = 1;
; 4035 :             if (eptr >= md->end_subject) break;
; 4036 :             GETCHARLEN(c, eptr, len);
; 4037 :             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
; 4038 :             eptr+= len;
; 4039 :             }
; 4040 :           break;
; 4041 : 
; 4042 :           default:
; 4043 :           RRETURN(PCRE_ERROR_INTERNAL);
; 4044 :           }
; 4045 : 
; 4046 :         /* eptr is now past the end of the maximum run */
; 4047 : 
; 4048 :         if (possessive) continue;
; 4049 :         for(;;)
; 4050 :           {
; 4051 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM46);
; 4052 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 4053 :           if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 4054 :           BACKCHAR(eptr);
; 4055 :           }
; 4056 :         }
; 4057 :       else
; 4058 : #endif  /* SUPPORT_UTF8 */
; 4059 : 
; 4060 :       /* Not UTF-8 mode */
; 4061 :         {
; 4062 :         switch(ctype)

	mov	eax, DWORD PTR _ctype$[esp+244]
	add	eax, -6					; fffffffaH
	cmp	eax, 14					; 0000000eH
	mov	DWORD PTR _pp$[esp+244], esi
	ja	$LN146@match
	jmp	DWORD PTR $LN1437@match[eax*4]
$LN88@match:

; 4063 :           {
; 4064 :           case OP_ANY:
; 4065 :           if ((ims & PCRE_DOTALL) == 0)

	test	BYTE PTR _ims$[esp+240], 4
	jne	$LN1312@match

; 4066 :             {
; 4067 :             for (i = min; i < max; i++)

	cmp	ebx, DWORD PTR _max$[esp+244]
	jge	$LN1313@match
$LL86@match:

; 4068 :               {
; 4069 :               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;

	mov	eax, DWORD PTR [ebp+88]
	cmp	esi, eax
	jae	$LN1313@match
	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN738@match
	push	0
	lea	edx, DWORD PTR [ebp+28]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	$LN1313@match
	jmp	SHORT $LN734@match
$LN738@match:
	mov	ecx, DWORD PTR [ebp+28]
	sub	eax, ecx
	cmp	esi, eax
	ja	SHORT $LN734@match
	mov	al, BYTE PTR [esi]
	cmp	al, BYTE PTR [ebp+32]
	jne	SHORT $LN734@match
	cmp	ecx, 1
	je	$LN1313@match
	mov	cl, BYTE PTR [esi+1]
	cmp	cl, BYTE PTR [ebp+33]
	je	$LN1313@match
$LN734@match:

; 4066 :             {
; 4067 :             for (i = min; i < max; i++)

	add	ebx, 1

; 4070 :               eptr++;

	add	esi, 1
	cmp	ebx, DWORD PTR _max$[esp+244]
	jl	SHORT $LL86@match

; 4071 :               }
; 4072 :             break;

	jmp	$LN1313@match
$LN1312@match:

; 4073 :             }
; 4074 :           /* For DOTALL case, fall through and treat as \C */
; 4075 : 
; 4076 :           case OP_ANYBYTE:
; 4077 :           c = max - min;

	mov	eax, DWORD PTR _max$[esp+244]
	sub	eax, ebx
	mov	ecx, eax

; 4078 :           if (c > (unsigned int)(md->end_subject - eptr))

	mov	eax, DWORD PTR [ebp+88]
	sub	eax, esi
	cmp	ecx, eax
	jbe	SHORT $LN80@match

; 4079 :             c = md->end_subject - eptr;

	mov	ecx, eax
$LN80@match:

; 4080 :           eptr += c;

	add	esi, ecx

; 4081 :           break;

	jmp	$LN1313@match
$LN79@match:

; 4082 : 
; 4083 :           case OP_ANYNL:
; 4084 :           for (i = min; i < max; i++)

	mov	edx, DWORD PTR _max$[esp+244]
	cmp	ebx, edx
	jge	$LN1313@match
	mov	ecx, DWORD PTR [ebp+88]
	npad	1
$LL78@match:

; 4085 :             {
; 4086 :             if (eptr >= md->end_subject) break;

	cmp	esi, ecx
	jae	$LN1313@match

; 4087 :             c = *eptr;

	movzx	eax, BYTE PTR [esi]

; 4088 :             if (c == 0x000d)

	cmp	eax, 13					; 0000000dH
	jne	SHORT $LN74@match

; 4089 :               {
; 4090 :               if (++eptr >= md->end_subject) break;

	add	esi, 1
	cmp	esi, ecx
	jae	$LN1313@match

; 4091 :               if (*eptr == 0x000a) eptr++;

	cmp	BYTE PTR [esi], 10			; 0000000aH
	jne	SHORT $LN77@match

; 4092 :               }
; 4093 :             else

	jmp	SHORT $LN70@match
$LN74@match:

; 4094 :               {
; 4095 :               if (c != 0x000a &&
; 4096 :                   (md->bsr_anycrlf ||
; 4097 :                     (c != 0x000b && c != 0x000c && c != 0x0085)))

	cmp	eax, 10					; 0000000aH
	je	SHORT $LN70@match
	cmp	DWORD PTR [ebp+76], 0
	jne	$LN1313@match
	cmp	eax, 11					; 0000000bH
	je	SHORT $LN70@match
	cmp	eax, 12					; 0000000cH
	je	SHORT $LN70@match
	cmp	eax, 133				; 00000085H
	jne	$LN1313@match
$LN70@match:

; 4098 :                 break;
; 4099 :               eptr++;

	add	esi, 1
$LN77@match:

; 4082 : 
; 4083 :           case OP_ANYNL:
; 4084 :           for (i = min; i < max; i++)

	add	ebx, 1
	cmp	ebx, edx
	jl	SHORT $LL78@match

; 4100 :               }
; 4101 :             }
; 4102 :           break;

	jmp	$LN1313@match
$LN68@match:

; 4103 : 
; 4104 :           case OP_NOT_HSPACE:
; 4105 :           for (i = min; i < max; i++)

	mov	ecx, DWORD PTR _max$[esp+244]
	cmp	ebx, ecx
	jge	$LN1313@match
	mov	edx, DWORD PTR [ebp+88]
$LL67@match:

; 4106 :             {
; 4107 :             if (eptr >= md->end_subject) break;

	cmp	esi, edx
	jae	$LN1313@match

; 4108 :             c = *eptr;

	movzx	eax, BYTE PTR [esi]

; 4109 :             if (c == 0x09 || c == 0x20 || c == 0xa0) break;

	cmp	eax, 9
	je	$LN1313@match
	cmp	eax, 32					; 00000020H
	je	$LN1313@match
	cmp	eax, 160				; 000000a0H
	je	$LN1313@match
	add	ebx, 1

; 4110 :             eptr++;

	add	esi, 1
	cmp	ebx, ecx
	jl	SHORT $LL67@match

; 4111 :             }
; 4112 :           break;

	jmp	$LN1313@match
$LN61@match:

; 4113 : 
; 4114 :           case OP_HSPACE:
; 4115 :           for (i = min; i < max; i++)

	mov	ecx, DWORD PTR _max$[esp+244]
	cmp	ebx, ecx
	jge	$LN1313@match
	mov	edx, DWORD PTR [ebp+88]
	npad	6
$LL60@match:

; 4116 :             {
; 4117 :             if (eptr >= md->end_subject) break;

	cmp	esi, edx
	jae	$LN1313@match

; 4118 :             c = *eptr;

	movzx	eax, BYTE PTR [esi]

; 4119 :             if (c != 0x09 && c != 0x20 && c != 0xa0) break;

	cmp	eax, 9
	je	SHORT $LN56@match
	cmp	eax, 32					; 00000020H
	je	SHORT $LN56@match
	cmp	eax, 160				; 000000a0H
	jne	$LN1313@match
$LN56@match:

; 4113 : 
; 4114 :           case OP_HSPACE:
; 4115 :           for (i = min; i < max; i++)

	add	ebx, 1

; 4120 :             eptr++;

	add	esi, 1
	cmp	ebx, ecx
	jl	SHORT $LL60@match

; 4121 :             }
; 4122 :           break;

	jmp	$LN1313@match
$LN55@match:

; 4123 : 
; 4124 :           case OP_NOT_VSPACE:
; 4125 :           for (i = min; i < max; i++)

	mov	ecx, DWORD PTR _max$[esp+244]
	cmp	ebx, ecx
	jge	$LN1313@match
	mov	edx, DWORD PTR [ebp+88]
	npad	2
$LL54@match:

; 4126 :             {
; 4127 :             if (eptr >= md->end_subject) break;

	cmp	esi, edx
	jae	$LN1313@match

; 4128 :             c = *eptr;

	movzx	eax, BYTE PTR [esi]

; 4129 :             if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)

	cmp	eax, 10					; 0000000aH
	je	$LN1313@match
	cmp	eax, 11					; 0000000bH
	je	$LN1313@match
	cmp	eax, 12					; 0000000cH
	je	$LN1313@match
	cmp	eax, 13					; 0000000dH
	je	$LN1313@match
	cmp	eax, 133				; 00000085H
	je	$LN1313@match
	add	ebx, 1

; 4130 :               break;
; 4131 :             eptr++;

	add	esi, 1
	cmp	ebx, ecx
	jl	SHORT $LL54@match

; 4132 :             }
; 4133 :           break;

	jmp	$LN1313@match
$LN48@match:

; 4134 : 
; 4135 :           case OP_VSPACE:
; 4136 :           for (i = min; i < max; i++)

	mov	ecx, DWORD PTR _max$[esp+244]
	cmp	ebx, ecx
	jge	$LN1313@match
	mov	edx, DWORD PTR [ebp+88]
$LL47@match:

; 4137 :             {
; 4138 :             if (eptr >= md->end_subject) break;

	cmp	esi, edx
	jae	$LN1313@match

; 4139 :             c = *eptr;

	movzx	eax, BYTE PTR [esi]

; 4140 :             if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)

	cmp	eax, 10					; 0000000aH
	je	SHORT $LN43@match
	cmp	eax, 11					; 0000000bH
	je	SHORT $LN43@match
	cmp	eax, 12					; 0000000cH
	je	SHORT $LN43@match
	cmp	eax, 13					; 0000000dH
	je	SHORT $LN43@match
	cmp	eax, 133				; 00000085H
	jne	$LN1313@match
$LN43@match:

; 4134 : 
; 4135 :           case OP_VSPACE:
; 4136 :           for (i = min; i < max; i++)

	add	ebx, 1

; 4141 :               break;
; 4142 :             eptr++;

	add	esi, 1
	cmp	ebx, ecx
	jl	SHORT $LL47@match

; 4143 :             }
; 4144 :           break;

	jmp	$LN1313@match
$LN42@match:

; 4145 : 
; 4146 :           case OP_NOT_DIGIT:
; 4147 :           for (i = min; i < max; i++)

	mov	eax, DWORD PTR _max$[esp+244]
	cmp	ebx, eax
	jge	$LN1313@match
	npad	3
$LL1342@match:

; 4148 :             {
; 4149 :             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN1313@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+ecx], 4
	jne	$LN1313@match
	add	ebx, 1

; 4150 :               break;
; 4151 :             eptr++;

	add	esi, 1
	cmp	ebx, eax
	jl	SHORT $LL1342@match

; 4152 :             }
; 4153 :           break;

	jmp	$LN1313@match
$LN36@match:

; 4154 : 
; 4155 :           case OP_DIGIT:
; 4156 :           for (i = min; i < max; i++)

	mov	eax, DWORD PTR _max$[esp+244]
	cmp	ebx, eax
	jge	$LN1313@match
$LL1344@match:

; 4157 :             {
; 4158 :             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN1313@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+ecx], 4
	je	$LN1313@match
	add	ebx, 1

; 4159 :               break;
; 4160 :             eptr++;

	add	esi, 1
	cmp	ebx, eax
	jl	SHORT $LL1344@match

; 4161 :             }
; 4162 :           break;

	jmp	$LN1313@match
$LN30@match:

; 4163 : 
; 4164 :           case OP_NOT_WHITESPACE:
; 4165 :           for (i = min; i < max; i++)

	mov	eax, DWORD PTR _max$[esp+244]
	cmp	ebx, eax
	jge	$LN1313@match
	npad	8
$LL1346@match:

; 4166 :             {
; 4167 :             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN1313@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+ecx], 1
	jne	$LN1313@match
	add	ebx, 1

; 4168 :               break;
; 4169 :             eptr++;

	add	esi, 1
	cmp	ebx, eax
	jl	SHORT $LL1346@match

; 4170 :             }
; 4171 :           break;

	jmp	$LN1313@match
$LN24@match:

; 4172 : 
; 4173 :           case OP_WHITESPACE:
; 4174 :           for (i = min; i < max; i++)

	mov	eax, DWORD PTR _max$[esp+244]
	cmp	ebx, eax
	jge	$LN1313@match
$LL1348@match:

; 4175 :             {
; 4176 :             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN1313@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+ecx], 1
	je	$LN1313@match
	add	ebx, 1

; 4177 :               break;
; 4178 :             eptr++;

	add	esi, 1
	cmp	ebx, eax
	jl	SHORT $LL1348@match

; 4179 :             }
; 4180 :           break;

	jmp	$LN1313@match
$LN18@match:

; 4181 : 
; 4182 :           case OP_NOT_WORDCHAR:
; 4183 :           for (i = min; i < max; i++)

	mov	eax, DWORD PTR _max$[esp+244]
	cmp	ebx, eax
	jge	SHORT $LN1313@match
$LL1350@match:

; 4184 :             {
; 4185 :             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1313@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+ecx], 16			; 00000010H
	jne	SHORT $LN1313@match
	add	ebx, 1

; 4186 :               break;
; 4187 :             eptr++;

	add	esi, 1
	cmp	ebx, eax
	jl	SHORT $LL1350@match

; 4188 :             }
; 4189 :           break;

	jmp	SHORT $LN1313@match
$LN12@match:

; 4190 : 
; 4191 :           case OP_WORDCHAR:
; 4192 :           for (i = min; i < max; i++)

	mov	eax, DWORD PTR _max$[esp+244]
	cmp	ebx, eax
	jge	SHORT $LN1313@match
	npad	7
$LL1352@match:

; 4193 :             {
; 4194 :             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1313@match
	movzx	edx, BYTE PTR [esi]
	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [edx+ecx], 16			; 00000010H
	je	SHORT $LN1313@match
	add	ebx, 1

; 4195 :               break;
; 4196 :             eptr++;

	add	esi, 1
	cmp	ebx, eax
	jl	SHORT $LL1352@match
$LN1313@match:

; 4197 :             }
; 4198 :           break;
; 4199 : 
; 4200 :           default:
; 4201 :           RRETURN(PCRE_ERROR_INTERNAL);
; 4202 :           }
; 4203 : 
; 4204 :         /* eptr is now past the end of the maximum run */
; 4205 : 
; 4206 :         if (possessive) continue;

	cmp	DWORD PTR _possessive$[esp+244], 0
	jne	$LL650@match

; 4207 :         while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jb	$LN3@match
	mov	ebx, DWORD PTR _rdepth$[esp+240]
	add	ebx, 1
	npad	6
$LL4@match:

; 4208 :           {
; 4209 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM47);

	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	mov	eax, DWORD PTR _offset_top$[esp+240]
	push	ebx
	push	0
	push	ecx
	mov	ecx, DWORD PTR _mstart$[esp+252]
	push	edx
	push	ebp
	push	eax
	push	ecx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 4210 :           eptr--;

	sub	esi, 1

; 4211 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 4207 :         while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL4@match
$LN3@match:
	pop	edi
	pop	esi
	pop	ebp

; 4212 :           }
; 4213 :         }
; 4214 : 
; 4215 :       /* Get here if we can't make it match with any permitted repetitions */
; 4216 : 
; 4217 :       RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN1181@match:

; 792  :         {
; 793  :         condition = TRUE;
; 794  :         ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+4]
	mov	dl, BYTE PTR [edi+5]

; 795  :         while (*ecode == OP_ALT) ecode += GET(ecode, 1);

	cmp	BYTE PTR [edi+edx+3], 83		; 00000053H
	lea	edi, DWORD PTR [edi+edx+3]
	jne	SHORT $LN1316@match
	npad	1
$LL616@match:
	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
	add	edi, eax
	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL616@match
$LN1316@match:

; 814  :       {
; 815  :       ecode += 1 + LINK_SIZE;

	add	edi, 3

; 816  :       if (op == OP_SCOND)        /* Possibly empty group */

	cmp	DWORD PTR _op$[esp+244], 98		; 00000062H
	jne	$LN1429@match

; 817  :         {
; 818  :         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	add	ecx, 1
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+244]
	push	2
	push	edx
	push	eax
	push	ebp
	push	ecx
	push	ebx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN636@match:

; 648  : 
; 649  :     /* Handle a capturing bracket. If there is space in the offset vector, save
; 650  :     the current subject position in the working slot at the top of the vector.
; 651  :     We mustn't change the current values of the data slot, because they may be
; 652  :     set from a previous iteration of this group, and be referred to by a
; 653  :     reference inside the group.
; 654  : 
; 655  :     If the bracket fails to match, we need to restore this value and also the
; 656  :     values of the final offsets, in case they were set by a previous iteration
; 657  :     of the same bracket.
; 658  : 
; 659  :     If there isn't enough space in the offset vector, treat this as if it were
; 660  :     a non-capturing bracket. Don't worry about setting the flag for the error
; 661  :     case here; that is handled in the code for KET. */
; 662  : 
; 663  :     case OP_CBRA:
; 664  :     case OP_SCBRA:
; 665  :     number = GET2(ecode, 1+LINK_SIZE);

	xor	eax, eax
	mov	ah, BYTE PTR [edi+3]
	mov	al, BYTE PTR [edi+4]

; 666  :     offset = number << 1;

	lea	edx, DWORD PTR [eax+eax]

; 667  : 
; 668  : #ifdef DEBUG
; 669  :     printf("start bracket %d\n", number);
; 670  :     printf("subject=");
; 671  :     pchars(eptr, 16, TRUE, md);
; 672  :     printf("\n");
; 673  : #endif
; 674  : 
; 675  :     if (offset < md->offset_max)

	cmp	edx, DWORD PTR [ebp+20]
	mov	DWORD PTR _number$[esp+244], eax
	jl	$LN944@match
$LN635@match:

; 703  :       }
; 704  : 
; 705  :     /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
; 706  :     as a non-capturing bracket. */
; 707  : 
; 708  :     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
; 709  :     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
; 710  : 
; 711  :     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
; 712  : 
; 713  :     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
; 714  :     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
; 715  : 
; 716  :     /* Non-capturing bracket. Loop for all the alternatives. When we get to the
; 717  :     final alternative within the brackets, we would return the result of a
; 718  :     recursive call to match() whatever happened. We can reduce stack usage by
; 719  :     turning this into a tail recursion, except in the case when match_cbegroup
; 720  :     is set.*/
; 721  : 
; 722  :     case OP_BRA:
; 723  :     case OP_SBRA:
; 724  :     DPRINTF(("start non-capturing bracket\n"));
; 725  :     flags = (op >= OP_SBRA)? match_cbegroup : 0;

	xor	eax, eax
	cmp	ecx, 96					; 00000060H
	setl	al

; 726  :     for (;;)
; 727  :       {
; 728  :       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */

	xor	ecx, ecx
	mov	ch, BYTE PTR [edi+1]
	sub	eax, 1
	and	eax, 2
	mov	cl, BYTE PTR [edi+2]
	mov	DWORD PTR _flags$[esp+240], eax
	cmp	BYTE PTR [ecx+edi], 83			; 00000053H
	jne	$LN940@match
	npad	8
$LL629@match:

; 742  :         }
; 743  : 
; 744  :       /* For non-final alternatives, continue the loop for a NOMATCH result;
; 745  :       otherwise return. */
; 746  : 
; 747  :       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
; 748  :         eptrb, flags, RM2);

	mov	eax, DWORD PTR _rdepth$[esp+240]
	mov	edx, DWORD PTR _flags$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	add	eax, 1
	push	eax
	mov	eax, DWORD PTR _eptrb$[esp+244]
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+248]
	push	eax
	movzx	eax, BYTE PTR [edi]
	push	ecx
	movzx	ecx, BYTE PTR __pcre_OP_lengths[eax]
	push	ebp
	push	edx
	push	ebx
	add	ecx, edi
	push	ecx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 749  :       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);

	test	eax, eax
	je	SHORT $LN625@match
	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN625@match:

; 750  :       ecode += GET(ecode, 1);

	xor	edx, edx
	mov	dh, BYTE PTR [edi+1]
	xor	eax, eax
	mov	dl, BYTE PTR [edi+2]
	mov	ah, BYTE PTR [edi+edx+1]
	add	edi, edx
	mov	al, BYTE PTR [edi+2]
	cmp	BYTE PTR [eax+edi], 83			; 00000053H
	je	SHORT $LL629@match

; 726  :     for (;;)
; 727  :       {
; 728  :       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */

	mov	eax, DWORD PTR _flags$[esp+240]
$LN940@match:

; 729  :         {
; 730  :         if (flags == 0)    /* Not a possibly empty group */

	test	eax, eax
	jne	$LN626@match

; 731  :           {
; 732  :           ecode += _pcre_OP_lengths[*ecode];

	movzx	ecx, BYTE PTR [edi]
	movzx	edx, BYTE PTR __pcre_OP_lengths[ecx]
	add	edi, edx

; 733  :           DPRINTF(("bracket 0 tail recursion\n"));
; 734  :           goto TAIL_RECURSE;

	jmp	$LN826@match
$LN556@match:

; 1110 :       }
; 1111 : 
; 1112 :     /* The repeating kets try the rest of the pattern or restart from the
; 1113 :     preceding bracket, in the appropriate order. The second "call" of match()
; 1114 :     uses tail recursion, to avoid using another stack frame. We need to reset
; 1115 :     any options that changed within the bracket before re-running it, so
; 1116 :     check the next opcode. */
; 1117 : 
; 1118 :     if (ecode[1+LINK_SIZE] == OP_OPT)

	cmp	BYTE PTR [edi+3], 24			; 00000018H
	lea	ecx, DWORD PTR [edi+3]
	mov	DWORD PTR tv3580[esp+244], ecx
	jne	SHORT $LN1318@match

; 1119 :       {
; 1120 :       ims = (ims & ~PCRE_IMS) | ecode[4];

	mov	edx, DWORD PTR _ims$[esp+240]
	movzx	ecx, BYTE PTR [edi+4]
	and	edx, -8					; fffffff8H
	or	ecx, edx
	mov	DWORD PTR _ims$[esp+240], ecx
$LN1318@match:

; 1121 :       DPRINTF(("ims set to %02lx at group repeat\n", ims));
; 1122 :       }
; 1123 : 
; 1124 :     if (*ecode == OP_KETRMIN)
; 1125 :       {
; 1126 :       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	add	ecx, 1
	cmp	BYTE PTR [edi], 86			; 00000056H
	push	ecx
	mov	ecx, DWORD PTR _ims$[esp+244]
	jne	SHORT $LN553@match
	push	0
	push	edx
	mov	edx, DWORD PTR tv3580[esp+256]
	push	ecx
	push	ebp
	push	eax
	push	ebx
	push	edx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1127 :       if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1128 :       ecode = prev;

	mov	edi, DWORD PTR _prev$[esp+244]

; 1129 :       flags = 0;
; 1130 :       goto TAIL_RECURSE;

	jmp	$LN1429@match
$LN553@match:

; 1131 :       }
; 1132 :     else  /* OP_KETRMAX */
; 1133 :       {
; 1134 :       RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);

	push	2
	push	edx
	mov	edx, DWORD PTR _prev$[esp+256]
	push	ecx
	push	ebp
	push	eax
	push	ebx
	push	edx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1135 :       if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1136 :       ecode += 1 + LINK_SIZE;

	mov	edi, DWORD PTR tv3580[esp+244]

; 1137 :       flags = 0;
; 1138 :       goto TAIL_RECURSE;

	jmp	$LN1429@match
$LN524@match:

; 1264 :       }
; 1265 : 
; 1266 :     /* The repeating kets try the rest of the pattern or restart from the
; 1267 :     preceding bracket, in the appropriate order. In the second case, we can use
; 1268 :     tail recursion to avoid using another stack frame, unless we have an
; 1269 :     unlimited repeat of a group that can match an empty string. */
; 1270 : 
; 1271 :     flags = (*prev >= OP_SBRA)? match_cbegroup : 0;

	cmp	BYTE PTR [ecx], 96			; 00000060H
	sbb	eax, eax
	and	eax, -2					; fffffffeH
	add	eax, 2

; 1272 : 
; 1273 :     if (*ecode == OP_KETRMIN)

	cmp	BYTE PTR [edi], 86			; 00000056H
	mov	DWORD PTR _flags$[esp+240], eax
	jne	SHORT $LN522@match

; 1274 :       {
; 1275 :       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);

	mov	eax, DWORD PTR _rdepth$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _original_ims$[esp+244]
	add	eax, 1
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+244]
	push	0
	push	ecx
	push	edx
	push	ebp
	push	eax
	push	ebx
	add	edi, 3
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1276 :       if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1277 :       if (flags != 0)    /* Could match an empty string */

	cmp	DWORD PTR _flags$[esp+240], eax
	jne	$LN949@match

; 1280 :         RRETURN(rrc);
; 1281 :         }
; 1282 :       ecode = prev;

	mov	edi, DWORD PTR _prev$[esp+244]

; 1283 :       goto TAIL_RECURSE;

	jmp	$LN826@match
$LN522@match:

; 1284 :       }
; 1285 :     else  /* OP_KETRMAX */
; 1286 :       {
; 1287 :       RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	mov	edx, DWORD PTR _flags$[esp+240]
	mov	eax, DWORD PTR _eptrb$[esp+240]
	add	ecx, 1
	push	ecx
	mov	ecx, DWORD PTR _original_ims$[esp+248]
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+248]
	push	eax
	mov	eax, DWORD PTR _prev$[esp+256]
	push	ecx
	push	ebp
	push	edx
	push	ebx
	push	eax
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1288 :       if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1289 :       ecode += 1 + LINK_SIZE;

	add	edi, 3
$LN1429@match:

; 1290 :       flags = 0;

	mov	DWORD PTR _flags$[esp+240], 0
$LN826@match:

; 404  : /* These variables do not need to be preserved over recursion in this function,
; 405  : so they can be ordinary variables in all cases. Mark some of them with
; 406  : "register" because they are used a lot in loops. */
; 407  : 
; 408  : register int  rrc;         /* Returns from recursive calls */
; 409  : register int  i;           /* Used for loops not involving calls to RMATCH() */
; 410  : register unsigned int c;   /* Character values not kept over RMATCH() calls */
; 411  : register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
; 412  : 
; 413  : BOOL minimize, possessive; /* Quantifier options */
; 414  : 
; 415  : /* When recursion is not being used, all "local" variables that have to be
; 416  : preserved over calls to RMATCH() are part of a "frame" which is obtained from
; 417  : heap storage. Set up the top-level frame here; others are obtained from the
; 418  : heap whenever RMATCH() does a "recursion". See the macro definitions above. */
; 419  : 
; 420  : #ifdef NO_RECURSE
; 421  : heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
; 422  : frame->Xprevframe = NULL;            /* Marks the top level */
; 423  : 
; 424  : /* Copy in the original argument variables */
; 425  : 
; 426  : frame->Xeptr = eptr;
; 427  : frame->Xecode = ecode;
; 428  : frame->Xmstart = mstart;
; 429  : frame->Xoffset_top = offset_top;
; 430  : frame->Xims = ims;
; 431  : frame->Xeptrb = eptrb;
; 432  : frame->Xflags = flags;
; 433  : frame->Xrdepth = rdepth;
; 434  : 
; 435  : /* This is where control jumps back to to effect "recursion" */
; 436  : 
; 437  : HEAP_RECURSE:
; 438  : 
; 439  : /* Macros make the argument variables come from the current frame */
; 440  : 
; 441  : #define eptr               frame->Xeptr
; 442  : #define ecode              frame->Xecode
; 443  : #define mstart             frame->Xmstart
; 444  : #define offset_top         frame->Xoffset_top
; 445  : #define ims                frame->Xims
; 446  : #define eptrb              frame->Xeptrb
; 447  : #define flags              frame->Xflags
; 448  : #define rdepth             frame->Xrdepth
; 449  : 
; 450  : /* Ditto for the local variables */
; 451  : 
; 452  : #ifdef SUPPORT_UTF8
; 453  : #define charptr            frame->Xcharptr
; 454  : #endif
; 455  : #define callpat            frame->Xcallpat
; 456  : #define data               frame->Xdata
; 457  : #define next               frame->Xnext
; 458  : #define pp                 frame->Xpp
; 459  : #define prev               frame->Xprev
; 460  : #define saved_eptr         frame->Xsaved_eptr
; 461  : 
; 462  : #define new_recursive      frame->Xnew_recursive
; 463  : 
; 464  : #define cur_is_word        frame->Xcur_is_word
; 465  : #define condition          frame->Xcondition
; 466  : #define prev_is_word       frame->Xprev_is_word
; 467  : 
; 468  : #define original_ims       frame->Xoriginal_ims
; 469  : 
; 470  : #ifdef SUPPORT_UCP
; 471  : #define prop_type          frame->Xprop_type
; 472  : #define prop_value         frame->Xprop_value
; 473  : #define prop_fail_result   frame->Xprop_fail_result
; 474  : #define prop_category      frame->Xprop_category
; 475  : #define prop_chartype      frame->Xprop_chartype
; 476  : #define prop_script        frame->Xprop_script
; 477  : #define oclength           frame->Xoclength
; 478  : #define occhars            frame->Xocchars
; 479  : #endif
; 480  : 
; 481  : #define ctype              frame->Xctype
; 482  : #define fc                 frame->Xfc
; 483  : #define fi                 frame->Xfi
; 484  : #define length             frame->Xlength
; 485  : #define max                frame->Xmax
; 486  : #define min                frame->Xmin
; 487  : #define number             frame->Xnumber
; 488  : #define offset             frame->Xoffset
; 489  : #define op                 frame->Xop
; 490  : #define save_capture_last  frame->Xsave_capture_last
; 491  : #define save_offset1       frame->Xsave_offset1
; 492  : #define save_offset2       frame->Xsave_offset2
; 493  : #define save_offset3       frame->Xsave_offset3
; 494  : #define stacksave          frame->Xstacksave
; 495  : 
; 496  : #define newptrb            frame->Xnewptrb
; 497  : 
; 498  : /* When recursion is being used, local variables are allocated on the stack and
; 499  : get preserved during recursion in the normal way. In this environment, fi and
; 500  : i, and fc and c, can be the same variables. */
; 501  : 
; 502  : #else         /* NO_RECURSE not defined */
; 503  : #define fi i
; 504  : #define fc c
; 505  : 
; 506  : 
; 507  : #ifdef SUPPORT_UTF8                /* Many of these variables are used only  */
; 508  : const uschar *charptr;             /* in small blocks of the code. My normal */
; 509  : #endif                             /* style of coding would have declared    */
; 510  : const uschar *callpat;             /* them within each of those blocks.      */
; 511  : const uschar *data;                /* However, in order to accommodate the   */
; 512  : const uschar *next;                /* version of this code that uses an      */
; 513  : USPTR         pp;                  /* external "stack" implemented on the    */
; 514  : const uschar *prev;                /* heap, it is easier to declare them all */
; 515  : USPTR         saved_eptr;          /* here, so the declarations can be cut   */
; 516  :                                    /* out in a block. The only declarations  */
; 517  : recursion_info new_recursive;      /* within blocks below are for variables  */
; 518  :                                    /* that do not have to be preserved over  */
; 519  : BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
; 520  : BOOL condition;
; 521  : BOOL prev_is_word;
; 522  : 
; 523  : unsigned long int original_ims;
; 524  : 
; 525  : #ifdef SUPPORT_UCP
; 526  : int prop_type;
; 527  : int prop_value;
; 528  : int prop_fail_result;
; 529  : int prop_category;
; 530  : int prop_chartype;
; 531  : int prop_script;
; 532  : int oclength;
; 533  : uschar occhars[8];
; 534  : #endif
; 535  : 
; 536  : int ctype;
; 537  : int length;
; 538  : int max;
; 539  : int min;
; 540  : int number;
; 541  : int offset;
; 542  : int op;
; 543  : int save_capture_last;
; 544  : int save_offset1, save_offset2, save_offset3;
; 545  : int stacksave[REC_STACK_SAVE_MAX];
; 546  : 
; 547  : eptrblock newptrb;
; 548  : #endif     /* NO_RECURSE */
; 549  : 
; 550  : /* These statements are here to stop the compiler complaining about unitialized
; 551  : variables. */
; 552  : 
; 553  : #ifdef SUPPORT_UCP
; 554  : prop_value = 0;
; 555  : prop_fail_result = 0;
; 556  : #endif
; 557  : 
; 558  : 
; 559  : /* This label is used for tail recursion, which is used in a few cases even
; 560  : when NO_RECURSE is not defined, in order to reduce the amount of stack that is
; 561  : used. Thanks to Ian Taylor for noticing this possibility and sending the
; 562  : original patch. */
; 563  : 
; 564  : TAIL_RECURSE:
; 565  : 
; 566  : /* OK, now we can get on with the real code of the function. Recursive calls
; 567  : are specified by the macro RMATCH and RRETURN is used to return. When
; 568  : NO_RECURSE is *not* defined, these just turn into a recursive call to match()
; 569  : and a "return", respectively (possibly with some debugging if DEBUG is
; 570  : defined). However, RMATCH isn't like a function call because it's quite a
; 571  : complicated macro. It has to be used in one particular way. This shouldn't,
; 572  : however, impact performance when true recursion is being used. */
; 573  : 
; 574  : #ifdef SUPPORT_UTF8
; 575  : utf8 = md->utf8;       /* Local copy of the flag */
; 576  : #else
; 577  : utf8 = FALSE;
; 578  : #endif
; 579  : 
; 580  : /* First check that we haven't called match() too many times, or that we
; 581  : haven't exceeded the recursive call limit. */
; 582  : 
; 583  : if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);

	mov	ecx, DWORD PTR [ebp]
	cmp	ecx, DWORD PTR [ebp+4]
	jb	$TAIL_RECURSE$5435
$LN1325@match:
	add	DWORD PTR [ebp], 1
	pop	edi
	pop	esi
	pop	ebp
	mov	eax, -8					; fffffff8H
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN943@match:
	pop	edi
	pop	esi
	pop	ebp

; 584  : if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);

	mov	eax, -21				; ffffffebH
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN644@match:

; 620  :     {
; 621  :     case OP_FAIL:
; 622  :     RRETURN(MATCH_NOMATCH);
; 623  : 
; 624  :     case OP_PRUNE:
; 625  :     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
; 626  :       ims, eptrb, flags, RM51);

	mov	edx, DWORD PTR _rdepth$[esp+240]
	mov	eax, DWORD PTR _flags$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	add	edx, 1
	push	edx
	mov	edx, DWORD PTR _ims$[esp+244]
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+248]
	push	ecx
	movzx	ecx, BYTE PTR [edi]
	push	edx
	movzx	edx, BYTE PTR __pcre_OP_lengths[ecx]
	push	ebp
	push	eax
	push	ebx
	add	edx, edi
	push	edx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 627  :     if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	pop	edi
	pop	esi
	pop	ebp

; 628  :     RRETURN(MATCH_PRUNE);

	mov	eax, -998				; fffffc1aH
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN642@match:

; 629  : 
; 630  :     case OP_COMMIT:
; 631  :     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
; 632  :       ims, eptrb, flags, RM52);

	mov	eax, DWORD PTR _rdepth$[esp+240]
	mov	ecx, DWORD PTR _flags$[esp+240]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	add	eax, 1
	push	eax
	mov	eax, DWORD PTR _ims$[esp+244]
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+248]
	push	edx
	movzx	edx, BYTE PTR [edi]
	push	eax
	movzx	eax, BYTE PTR __pcre_OP_lengths[edx]
	push	ebp
	push	ecx
	push	ebx
	add	eax, edi
	push	eax
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 633  :     if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	pop	edi
	pop	esi
	pop	ebp

; 634  :     RRETURN(MATCH_COMMIT);

	mov	eax, -999				; fffffc19H
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN640@match:

; 635  : 
; 636  :     case OP_SKIP:
; 637  :     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
; 638  :       ims, eptrb, flags, RM53);

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	mov	edx, DWORD PTR _flags$[esp+240]
	mov	eax, DWORD PTR _eptrb$[esp+240]
	add	ecx, 1
	push	ecx
	mov	ecx, DWORD PTR _ims$[esp+244]
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+248]
	push	eax
	movzx	eax, BYTE PTR [edi]
	push	ecx
	movzx	ecx, BYTE PTR __pcre_OP_lengths[eax]
	push	ebp
	push	edx
	push	ebx
	add	ecx, edi
	push	ecx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 639  :     if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	pop	edi

; 640  :     md->start_match_ptr = eptr;   /* Pass back current position */

	mov	DWORD PTR [ebp+92], esi
	pop	esi
	pop	ebp

; 641  :     RRETURN(MATCH_SKIP);

	mov	eax, -997				; fffffc1bH
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN638@match:

; 642  : 
; 643  :     case OP_THEN:
; 644  :     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
; 645  :       ims, eptrb, flags, RM54);

	mov	edx, DWORD PTR _rdepth$[esp+240]
	mov	eax, DWORD PTR _flags$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	add	edx, 1
	push	edx
	mov	edx, DWORD PTR _ims$[esp+244]
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+248]
	push	ecx
	movzx	ecx, BYTE PTR [edi]
	push	edx
	movzx	edx, BYTE PTR __pcre_OP_lengths[ecx]
	push	ebp
	push	eax
	push	ebx
	add	edx, edi
	push	edx
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 646  :     if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	pop	edi
	pop	esi
	pop	ebp

; 647  :     RRETURN(MATCH_THEN);

	mov	eax, -996				; fffffc1cH
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN944@match:

; 676  :       {
; 677  :       save_offset1 = md->offset_vector[offset];

	mov	eax, DWORD PTR [ebp+12]
	mov	ecx, DWORD PTR [eax+edx*4]

; 678  :       save_offset2 = md->offset_vector[offset+1];

	mov	edx, DWORD PTR [eax+edx*4+4]
	mov	DWORD PTR _save_offset1$[esp+244], ecx

; 679  :       save_offset3 = md->offset_vector[md->offset_end - number];

	mov	ecx, DWORD PTR [ebp+16]
	sub	ecx, DWORD PTR _number$[esp+244]
	mov	DWORD PTR _save_offset2$[esp+244], edx
	mov	edx, DWORD PTR [eax+ecx*4]
	lea	eax, DWORD PTR [eax+ecx*4]

; 680  :       save_capture_last = md->capture_last;

	mov	ecx, DWORD PTR [ebp+104]
	mov	DWORD PTR _save_offset3$[esp+244], edx

; 681  : 
; 682  :       DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
; 683  :       md->offset_vector[md->offset_end - number] = eptr - md->start_subject;

	mov	edx, esi
	sub	edx, DWORD PTR [ebp+84]
	mov	DWORD PTR _save_capture_last$[esp+244], ecx

; 684  : 
; 685  :       flags = (op == OP_SCBRA)? match_cbegroup : 0;

	mov	ecx, DWORD PTR _rdepth$[esp+240]
	mov	DWORD PTR [eax], edx
	xor	eax, eax
	cmp	DWORD PTR _op$[esp+244], 97		; 00000061H
	setne	al
	sub	eax, 1
	and	eax, 2
	add	ecx, 1
	mov	DWORD PTR _flags$[esp+240], eax

; 1944 :             }
; 1945 :           }
; 1946 :         /* Control never gets here */
; 1947 :         }
; 1948 : 
; 1949 :       /* If maximizing, find the longest possible run, then work backwards. */
; 1950 : 
; 1951 :       else
; 1952 :         {
; 1953 :         pp = eptr;
; 1954 : 
; 1955 : #ifdef SUPPORT_UTF8
; 1956 :         /* UTF-8 mode */
; 1957 :         if (utf8)
; 1958 :           {
; 1959 :           for (i = min; i < max; i++)
; 1960 :             {
; 1961 :             int len = 1;
; 1962 :             if (eptr >= md->end_subject) break;
; 1963 :             GETCHARLEN(c, eptr, len);
; 1964 :             if (c > 255)
; 1965 :               {
; 1966 :               if (op == OP_CLASS) break;
; 1967 :               }
; 1968 :             else
; 1969 :               {
; 1970 :               if ((data[c/8] & (1 << (c&7))) == 0) break;
; 1971 :               }
; 1972 :             eptr += len;
; 1973 :             }
; 1974 :           for (;;)
; 1975 :             {
; 1976 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
; 1977 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 1978 :             if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 1979 :             BACKCHAR(eptr);
; 1980 :             }
; 1981 :           }
; 1982 :         else
; 1983 : #endif
; 1984 :           /* Not UTF-8 mode */
; 1985 :           {
; 1986 :           for (i = min; i < max; i++)

	mov	DWORD PTR tv3629[esp+244], ecx
$LL634@match:
	mov	edx, DWORD PTR tv3629[esp+244]
	mov	eax, DWORD PTR _flags$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	push	edx
	mov	edx, DWORD PTR _ims$[esp+244]
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+248]
	push	ecx
	movzx	ecx, BYTE PTR [edi]
	push	edx
	movzx	edx, BYTE PTR __pcre_OP_lengths[ecx]
	push	ebp
	push	eax
	push	ebx
	add	edx, edi
	push	edx
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LN631@match

; 686  :       do
; 687  :         {
; 688  :         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
; 689  :           ims, eptrb, flags, RM1);
; 690  :         if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);

	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN631@match:

; 691  :         md->capture_last = save_capture_last;

	mov	eax, DWORD PTR _save_capture_last$[esp+244]

; 692  :         ecode += GET(ecode, 1);

	xor	ecx, ecx
	mov	DWORD PTR [ebp+104], eax
	mov	ch, BYTE PTR [edi+1]
	mov	cl, BYTE PTR [edi+2]
	add	edi, ecx

; 693  :         }
; 694  :       while (*ecode == OP_ALT);

	cmp	BYTE PTR [edi], 83			; 00000053H
	je	SHORT $LL634@match

; 695  : 
; 696  :       DPRINTF(("bracket %d failed\n", number));
; 697  : 
; 698  :       md->offset_vector[offset] = save_offset1;

	mov	ecx, DWORD PTR _number$[esp+244]
	mov	edx, DWORD PTR [ebp+12]
	mov	esi, DWORD PTR _save_offset1$[esp+244]
	lea	eax, DWORD PTR [ecx+ecx]
	mov	DWORD PTR [edx+eax*4], esi

; 699  :       md->offset_vector[offset+1] = save_offset2;

	mov	edx, DWORD PTR [ebp+12]
	mov	esi, DWORD PTR _save_offset2$[esp+244]
	mov	DWORD PTR [edx+eax*4+4], esi

; 700  :       md->offset_vector[md->offset_end - number] = save_offset3;

	mov	eax, DWORD PTR [ebp+16]
	mov	edx, DWORD PTR _save_offset3$[esp+244]
	sub	eax, ecx
	mov	ecx, DWORD PTR [ebp+12]
	mov	DWORD PTR [ecx+eax*4], edx
$LN645@match:
	pop	edi
	pop	esi
	pop	ebp

; 701  : 
; 702  :       RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN626@match:

; 735  :           }
; 736  : 
; 737  :         /* Possibly empty group; can't use tail recursion. */
; 738  : 
; 739  :         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
; 740  :           eptrb, flags, RM48);

	mov	eax, DWORD PTR _rdepth$[esp+240]
	mov	ecx, DWORD PTR _flags$[esp+240]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	add	eax, 1
	push	eax
	mov	eax, DWORD PTR _ims$[esp+244]
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+248]
	push	edx

; 741  :         RRETURN(rrc);

	movzx	edx, BYTE PTR [edi]
	push	eax
	movzx	eax, BYTE PTR __pcre_OP_lengths[edx]
	push	ebp
	push	ecx
	push	ebx
	add	eax, edi
	push	eax
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN605@match:

; 851  :       }
; 852  : 
; 853  :     /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
; 854  :     string - backtracking will then try other alternatives, if any. */
; 855  : 
; 856  :     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);

	cmp	DWORD PTR [ebp+64], 0
	je	SHORT $LN604@match
	cmp	esi, ebx
	je	SHORT $LN645@match
$LN604@match:

; 857  :     md->end_match_ptr = eptr;           /* Record where we ended */
; 858  :     md->end_offset_top = offset_top;    /* and how many extracts were taken */

	mov	edx, DWORD PTR _offset_top$[esp+240]
	mov	DWORD PTR [ebp+96], esi
	mov	DWORD PTR [ebp+100], edx

; 859  :     md->start_match_ptr = mstart;       /* and the start (\K can modify) */

	mov	DWORD PTR [ebp+92], ebx
$LN880@match:
	pop	edi
	pop	esi
	pop	ebp

; 860  :     RRETURN(MATCH_MATCH);

	mov	eax, 1
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN578@match:

; 977  : 
; 978  :     /* Recursion either matches the current regex, or some subexpression. The
; 979  :     offset data is the offset to the starting bracket from the start of the
; 980  :     whole pattern. (This is so that it works from duplicated subpatterns.)
; 981  : 
; 982  :     If there are any capturing brackets started but not finished, we have to
; 983  :     save their starting points and reinstate them after the recursion. However,
; 984  :     we don't know how many such there are (offset_top records the completed
; 985  :     total) so we just have to save all the potential data. There may be up to
; 986  :     65535 such values, which is too large to put on the stack, but using malloc
; 987  :     for small numbers seems expensive. As a compromise, the stack is used when
; 988  :     there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
; 989  :     is used. A problem is what to do if the malloc fails ... there is no way of
; 990  :     returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
; 991  :     values on the stack, and accept that the rest may be wrong.
; 992  : 
; 993  :     There are also other values that have to be saved. We use a chained
; 994  :     sequence of blocks that actually live on the stack. Thanks to Robin Houston
; 995  :     for the original version of this logic. */
; 996  : 
; 997  :     case OP_RECURSE:
; 998  :       {
; 999  :       callpat = md->start_code + GET(ecode, 1);

	mov	ecx, DWORD PTR [ebp+80]
	xor	eax, eax
	mov	ah, BYTE PTR [edi+1]
	mov	al, BYTE PTR [edi+2]
	add	eax, ecx

; 1000 :       new_recursive.group_num = (callpat == md->start_code)? 0 :
; 1001 :         GET2(callpat, 1 + LINK_SIZE);

	cmp	eax, ecx
	mov	DWORD PTR _callpat$[esp+244], eax
	jne	SHORT $LN665@match
	mov	DWORD PTR _new_recursive$[esp+248], 0
	jmp	SHORT $LN666@match
$LN665@match:
	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+3]
	mov	cl, BYTE PTR [eax+4]
	mov	DWORD PTR _new_recursive$[esp+248], ecx
$LN666@match:

; 1002 : 
; 1003 :       /* Add to "recursing stack" */
; 1004 : 
; 1005 :       new_recursive.prevrec = md->recursive;
; 1006 :       md->recursive = &new_recursive;
; 1007 : 
; 1008 :       /* Find where to continue from afterwards */
; 1009 : 
; 1010 :       ecode += 1 + LINK_SIZE;
; 1011 :       new_recursive.after_call = ecode;
; 1012 : 
; 1013 :       /* Now save the offset data. */
; 1014 : 
; 1015 :       new_recursive.saved_max = md->offset_end;

	mov	ecx, DWORD PTR [ebp+16]
	mov	edx, DWORD PTR [ebp+120]
	add	edi, 3

; 1016 :       if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)

	cmp	ecx, 30					; 0000001eH
	lea	eax, DWORD PTR _new_recursive$[esp+244]
	mov	DWORD PTR _new_recursive$[esp+244], edx
	mov	DWORD PTR [ebp+120], eax
	mov	DWORD PTR _new_recursive$[esp+252], edi
	mov	DWORD PTR _new_recursive$[esp+264], ecx
	jg	SHORT $LN577@match

; 1017 :         new_recursive.offset_save = stacksave;

	lea	eax, DWORD PTR _stacksave$[esp+244]
	mov	DWORD PTR _new_recursive$[esp+260], eax

; 1018 :       else

	jmp	SHORT $LN575@match
$LN577@match:

; 1019 :         {
; 1020 :         new_recursive.offset_save =
; 1021 :           (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));

	add	ecx, ecx
	add	ecx, ecx
	push	ecx
	call	DWORD PTR _pcre_malloc
	add	esp, 4

; 1022 :         if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);

	test	eax, eax
	mov	DWORD PTR _new_recursive$[esp+260], eax
	jne	SHORT $LN1307@match
	pop	edi
	pop	esi
	pop	ebp
	mov	eax, -6					; fffffffaH
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN1307@match:

; 1022 :         if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);

	mov	ecx, DWORD PTR _new_recursive$[esp+264]
$LN575@match:

; 1023 :         }
; 1024 : 
; 1025 :       memcpy(new_recursive.offset_save, md->offset_vector,
; 1026 :             new_recursive.saved_max * sizeof(int));

	lea	edx, DWORD PTR [ecx*4]
	mov	ecx, DWORD PTR [ebp+12]
	push	edx
	push	ecx
	push	eax
	call	_memcpy

; 1027 :       new_recursive.save_start = mstart;
; 1028 :       mstart = eptr;
; 1029 : 
; 1030 :       /* OK, now we can do the recursion. For each top-level alternative we
; 1031 :       restore the offset and recursion data. */
; 1032 : 
; 1033 :       DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
; 1034 :       flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;

	mov	edx, DWORD PTR _rdepth$[esp+252]
	mov	DWORD PTR _new_recursive$[esp+268], ebx
	mov	ebx, DWORD PTR _callpat$[esp+256]
	mov	al, BYTE PTR [ebx]
	add	esp, 12					; 0000000cH
	cmp	al, 96					; 00000060H
	sbb	edi, edi
	and	edi, -2					; fffffffeH
	add	edi, 2
	add	edx, 1

; 1057 :         }
; 1058 :       while (*callpat == OP_ALT);

	mov	DWORD PTR tv3629[esp+244], edx
	npad	5
$LL574@match:
	mov	ecx, DWORD PTR tv3629[esp+244]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	push	ecx
	mov	ecx, DWORD PTR _ims$[esp+244]
	push	edi
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+252]
	push	ecx
	movzx	eax, al
	movzx	ecx, BYTE PTR __pcre_OP_lengths[eax]
	push	ebp
	push	edx
	push	esi
	add	ecx, ebx
	push	ecx
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	cmp	eax, 1
	je	$LN953@match

; 1046 :           }
; 1047 :         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)

	test	eax, eax
	je	SHORT $LN568@match
	cmp	eax, -996				; fffffc1cH
	jne	$LN649@match
$LN568@match:

; 1048 :           {
; 1049 :           DPRINTF(("Recursion gave error %d\n", rrc));
; 1050 :           RRETURN(rrc);
; 1051 :           }
; 1052 : 
; 1053 :         md->recursive = &new_recursive;
; 1054 :         memcpy(md->offset_vector, new_recursive.offset_save,
; 1055 :             new_recursive.saved_max * sizeof(int));

	mov	eax, DWORD PTR _new_recursive$[esp+264]
	lea	edx, DWORD PTR _new_recursive$[esp+244]
	lea	ecx, DWORD PTR [eax*4]
	mov	eax, DWORD PTR [ebp+12]
	mov	DWORD PTR [ebp+120], edx
	mov	edx, DWORD PTR _new_recursive$[esp+260]
	push	ecx
	push	edx
	push	eax
	call	_memcpy

; 1056 :         callpat += GET(callpat, 1);

	xor	ecx, ecx
	mov	ch, BYTE PTR [ebx+1]
	add	esp, 12					; 0000000cH
	mov	cl, BYTE PTR [ebx+2]

; 1057 :         }
; 1058 :       while (*callpat == OP_ALT);

	mov	al, BYTE PTR [ebx+ecx]
	add	ebx, ecx
	cmp	al, 83					; 00000053H
	je	$LL574@match

; 1059 : 
; 1060 :       DPRINTF(("Recursion didn't match\n"));
; 1061 :       md->recursive = new_recursive.prevrec;
; 1062 :       if (new_recursive.offset_save != stacksave)

	mov	eax, DWORD PTR _new_recursive$[esp+260]
	mov	edx, DWORD PTR _new_recursive$[esp+244]
	lea	ecx, DWORD PTR _stacksave$[esp+244]
	cmp	eax, ecx
	mov	DWORD PTR [ebp+120], edx
	je	SHORT $LN567@match

; 1063 :         (pcre_free)(new_recursive.offset_save);

	push	eax
	call	DWORD PTR _pcre_free
	add	esp, 4
$LN567@match:
	pop	edi
	pop	esi
	pop	ebp

; 1064 :       RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN953@match:

; 1035 :       do
; 1036 :         {
; 1037 :         RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
; 1038 :           md, ims, eptrb, flags, RM6);
; 1039 :         if (rrc == MATCH_MATCH)
; 1040 :           {
; 1041 :           DPRINTF(("Recursion matched\n"));
; 1042 :           md->recursive = new_recursive.prevrec;
; 1043 :           if (new_recursive.offset_save != stacksave)

	mov	eax, DWORD PTR _new_recursive$[esp+260]
	mov	edx, DWORD PTR _new_recursive$[esp+244]
	lea	ecx, DWORD PTR _stacksave$[esp+244]
	cmp	eax, ecx
	mov	DWORD PTR [ebp+120], edx
	je	SHORT $LN570@match

; 1044 :             (pcre_free)(new_recursive.offset_save);

	push	eax
	call	DWORD PTR _pcre_free
	add	esp, 4
$LN570@match:
	pop	edi
	pop	esi
	pop	ebp

; 1045 :           RRETURN(MATCH_MATCH);

	mov	eax, 1
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN949@match:

; 1278 :         {
; 1279 :         RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);

	mov	edx, DWORD PTR _rdepth$[esp+240]
	mov	eax, DWORD PTR _flags$[esp+240]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	add	edx, 1
	push	edx
	mov	edx, DWORD PTR _original_ims$[esp+248]
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+248]
	push	ecx
	mov	ecx, DWORD PTR _prev$[esp+256]
	push	edx
	push	ebp
	push	eax
	push	ebx
	push	ecx
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN531@match:

; 1200 :       {
; 1201 :       md->end_match_ptr = eptr;      /* For ONCE */
; 1202 :       md->end_offset_top = offset_top;

	mov	edx, DWORD PTR _offset_top$[esp+240]
	pop	edi
	mov	DWORD PTR [ebp+96], esi
	pop	esi
	mov	DWORD PTR [ebp+100], edx
	pop	ebp

; 1203 :       RRETURN(MATCH_MATCH);

	mov	eax, 1
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN413@match:

; 1798 :           }
; 1799 :         /* Control never gets here */
; 1800 :         }
; 1801 : 
; 1802 :       /* If maximizing, find the longest string and work backwards */
; 1803 : 
; 1804 :       else
; 1805 :         {
; 1806 :         pp = eptr;
; 1807 :         for (i = min; i < max; i++)

	cmp	eax, ecx
	mov	DWORD PTR _pp$[esp+244], esi
	mov	DWORD PTR _i$[esp+244], eax
	jge	$LN1165@match
	npad	2
$LL405@match:

; 1808 :           {
; 1809 :           if (!match_ref(offset, eptr, length, md, ims)) break;

	mov	eax, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset$[esp+244]
	push	eax
	push	esi
	mov	ecx, ebp
	mov	eax, ebx
	call	_match_ref
	add	esp, 8
	test	eax, eax
	je	SHORT $LN958@match
	mov	eax, DWORD PTR _i$[esp+244]
	add	eax, 1

; 1810 :           eptr += length;

	add	esi, ebx
	cmp	eax, DWORD PTR _max$[esp+244]
	mov	DWORD PTR _i$[esp+244], eax
	jl	SHORT $LL405@match
$LN958@match:

; 1811 :           }
; 1812 :         while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jb	$LN400@match
$LN1165@match:
	mov	ecx, DWORD PTR _rdepth$[esp+240]
	add	ecx, 1
	mov	DWORD PTR tv3629[esp+244], ecx
	npad	8
$LL401@match:

; 1813 :           {
; 1814 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);

	mov	edx, DWORD PTR tv3629[esp+244]
	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1815 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1816 :           eptr -= length;

	sub	esi, ebx
	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL401@match
$LN400@match:
	pop	edi
	pop	esi
	pop	ebp

; 1817 :           }
; 1818 :         RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN384@match:

; 1944 :             }
; 1945 :           }
; 1946 :         /* Control never gets here */
; 1947 :         }
; 1948 : 
; 1949 :       /* If maximizing, find the longest possible run, then work backwards. */
; 1950 : 
; 1951 :       else
; 1952 :         {
; 1953 :         pp = eptr;
; 1954 : 
; 1955 : #ifdef SUPPORT_UTF8
; 1956 :         /* UTF-8 mode */
; 1957 :         if (utf8)
; 1958 :           {
; 1959 :           for (i = min; i < max; i++)
; 1960 :             {
; 1961 :             int len = 1;
; 1962 :             if (eptr >= md->end_subject) break;
; 1963 :             GETCHARLEN(c, eptr, len);
; 1964 :             if (c > 255)
; 1965 :               {
; 1966 :               if (op == OP_CLASS) break;
; 1967 :               }
; 1968 :             else
; 1969 :               {
; 1970 :               if ((data[c/8] & (1 << (c&7))) == 0) break;
; 1971 :               }
; 1972 :             eptr += len;
; 1973 :             }
; 1974 :           for (;;)
; 1975 :             {
; 1976 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
; 1977 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 1978 :             if (eptr-- == pp) break;        /* Stop if tried at original pos */
; 1979 :             BACKCHAR(eptr);
; 1980 :             }
; 1981 :           }
; 1982 :         else
; 1983 : #endif
; 1984 :           /* Not UTF-8 mode */
; 1985 :           {
; 1986 :           for (i = min; i < max; i++)

	cmp	ecx, eax
	mov	DWORD PTR _pp$[esp+244], esi
	jge	SHORT $LN1168@match
$LL1326@match:

; 1987 :             {
; 1988 :             if (eptr >= md->end_subject) break;

	cmp	esi, DWORD PTR [ebp+88]
	jae	SHORT $LN1327@match

; 1989 :             c = *eptr;

	movzx	eax, BYTE PTR [esi]

; 1990 :             if ((data[c/8] & (1 << (c&7))) == 0) break;

	mov	ecx, eax
	and	ecx, 7
	mov	edx, 1
	shl	edx, cl
	mov	ecx, DWORD PTR _data$[esp+244]
	shr	eax, 3
	mov	al, BYTE PTR [eax+ecx]
	test	dl, al
	je	SHORT $LN1327@match
	mov	eax, DWORD PTR _i$[esp+244]
	add	eax, 1

; 1991 :             eptr++;

	add	esi, 1
	cmp	eax, DWORD PTR _max$[esp+244]
	mov	DWORD PTR _i$[esp+244], eax
	jl	SHORT $LL1326@match
$LN1327@match:

; 1992 :             }
; 1993 :           while (eptr >= pp)

	cmp	esi, DWORD PTR _pp$[esp+244]
	jb	$LN369@match
$LN1168@match:
	mov	ecx, DWORD PTR _rdepth$[esp+240]
	add	ecx, 1
	mov	DWORD PTR tv3629[esp+244], ecx
$LL370@match:

; 1994 :             {
; 1995 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);

	mov	edx, DWORD PTR tv3629[esp+244]
	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	push	edx
	mov	edx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	eax
	push	ecx
	push	ebp
	push	edx
	push	ebx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 1996 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match

; 1997 :             eptr--;

	sub	esi, 1
	cmp	esi, DWORD PTR _pp$[esp+244]
	jae	SHORT $LL370@match
$LN369@match:
	pop	edi
	pop	esi
	pop	ebp

; 1998 :             }
; 1999 :           }
; 2000 : 
; 2001 :         RRETURN(MATCH_NOMATCH);

	xor	eax, eax
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN930@match:

; 2364 :         {
; 2365 :         for (fi = min;; fi++)
; 2366 :           {
; 2367 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);

	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset_top$[esp+240]
	mov	DWORD PTR _i$[esp+244], eax
	mov	eax, DWORD PTR _rdepth$[esp+240]
	add	eax, 1
	push	eax
	push	0
	mov	DWORD PTR tv3629[esp+252], eax
	mov	eax, DWORD PTR _eptrb$[esp+248]
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2368 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
$LL345@match:

; 2369 :           if (fi >= max || eptr >= md->end_subject ||
; 2370 :               fc != md->lcc[*eptr++])

	cmp	DWORD PTR _i$[esp+244], ebx
	jge	$LN645@match
	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match
	movzx	ecx, BYTE PTR [esi]
	mov	edx, DWORD PTR [ebp+36]
	movzx	eax, BYTE PTR [ecx+edx]
	add	esi, 1
	cmp	DWORD PTR _c$[esp+244], eax
	jne	$LN645@match
	mov	ecx, DWORD PTR tv3629[esp+244]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	edx
	mov	edx, DWORD PTR _mstart$[esp+252]
	push	eax
	push	ebp
	push	ecx
	push	edx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LL345@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN931@match:

; 2402 :         {
; 2403 :         for (fi = min;; fi++)
; 2404 :           {
; 2405 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);

	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	mov	DWORD PTR _i$[esp+244], eax
	mov	eax, DWORD PTR _rdepth$[esp+240]
	add	eax, 1
	push	eax
	push	0
	push	ecx
	mov	ecx, DWORD PTR _mstart$[esp+252]
	push	edx
	push	ebp
	mov	DWORD PTR tv3629[esp+264], eax
	mov	eax, DWORD PTR _offset_top$[esp+260]
	push	eax
	push	ecx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2406 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	npad	2
$LL322@match:

; 2407 :           if (fi >= max || eptr >= md->end_subject || fc != *eptr++)

	cmp	DWORD PTR _i$[esp+244], ebx
	jge	$LN645@match
	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match
	movzx	edx, BYTE PTR [esi]
	add	esi, 1
	cmp	DWORD PTR _c$[esp+244], edx
	jne	$LN645@match
	mov	eax, DWORD PTR tv3629[esp+244]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+244]
	push	0
	push	ecx
	mov	ecx, DWORD PTR _mstart$[esp+252]
	push	edx
	push	ebp
	push	eax
	push	ecx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LL322@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN936@match:

; 2560 :         {
; 2561 : #ifdef SUPPORT_UTF8
; 2562 :         /* UTF-8 mode */
; 2563 :         if (utf8)
; 2564 :           {
; 2565 :           register unsigned int d;
; 2566 :           for (fi = min;; fi++)
; 2567 :             {
; 2568 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
; 2569 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2570 :             GETCHARINC(d, eptr);
; 2571 :             if (d < 256) d = md->lcc[d];
; 2572 :             if (fi >= max || eptr >= md->end_subject || fc == d)
; 2573 :               RRETURN(MATCH_NOMATCH);
; 2574 :             }
; 2575 :           }
; 2576 :         else
; 2577 : #endif
; 2578 :         /* Not UTF-8 mode */
; 2579 :           {
; 2580 :           for (fi = min;; fi++)
; 2581 :             {
; 2582 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);

	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset_top$[esp+240]
	mov	DWORD PTR _i$[esp+244], eax
	mov	eax, DWORD PTR _rdepth$[esp+240]
	add	eax, 1
	push	eax
	push	0
	mov	DWORD PTR tv3629[esp+252], eax
	mov	eax, DWORD PTR _eptrb$[esp+248]
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2583 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
$LL284@match:

; 2584 :             if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])

	cmp	DWORD PTR _i$[esp+244], ebx
	jge	$LN645@match
	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match
	movzx	ecx, BYTE PTR [esi]
	mov	edx, DWORD PTR [ebp+36]
	movzx	eax, BYTE PTR [ecx+edx]
	add	esi, 1
	cmp	DWORD PTR _c$[esp+244], eax
	je	$LN645@match
	mov	ecx, DWORD PTR tv3629[esp+244]
	mov	edx, DWORD PTR _eptrb$[esp+240]
	mov	eax, DWORD PTR _ims$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	ecx
	mov	ecx, DWORD PTR _offset_top$[esp+244]
	push	0
	push	edx
	mov	edx, DWORD PTR _mstart$[esp+252]
	push	eax
	push	ebp
	push	ecx
	push	edx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LL284@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN937@match:

; 2669 :         {
; 2670 : #ifdef SUPPORT_UTF8
; 2671 :         /* UTF-8 mode */
; 2672 :         if (utf8)
; 2673 :           {
; 2674 :           register unsigned int d;
; 2675 :           for (fi = min;; fi++)
; 2676 :             {
; 2677 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
; 2678 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 2679 :             GETCHARINC(d, eptr);
; 2680 :             if (fi >= max || eptr >= md->end_subject || fc == d)
; 2681 :               RRETURN(MATCH_NOMATCH);
; 2682 :             }
; 2683 :           }
; 2684 :         else
; 2685 : #endif
; 2686 :         /* Not UTF-8 mode */
; 2687 :           {
; 2688 :           for (fi = min;; fi++)
; 2689 :             {
; 2690 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);

	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	mov	DWORD PTR _i$[esp+244], eax
	mov	eax, DWORD PTR _rdepth$[esp+240]
	add	eax, 1
	push	eax
	push	0
	push	ecx
	mov	ecx, DWORD PTR _mstart$[esp+252]
	push	edx
	push	ebp
	mov	DWORD PTR tv3629[esp+264], eax
	mov	eax, DWORD PTR _offset_top$[esp+260]
	push	eax
	push	ecx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 2691 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	npad	7
$LL261@match:

; 2692 :             if (fi >= max || eptr >= md->end_subject || fc == *eptr++)

	cmp	DWORD PTR _i$[esp+244], ebx
	jge	$LN645@match
	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN645@match
	movzx	edx, BYTE PTR [esi]
	add	esi, 1
	cmp	DWORD PTR _c$[esp+244], edx
	je	$LN645@match
	mov	eax, DWORD PTR tv3629[esp+244]
	mov	ecx, DWORD PTR _eptrb$[esp+240]
	mov	edx, DWORD PTR _ims$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	eax
	mov	eax, DWORD PTR _offset_top$[esp+244]
	push	0
	push	ecx
	mov	ecx, DWORD PTR _mstart$[esp+252]
	push	edx
	push	ebp
	push	eax
	push	ecx
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H
	test	eax, eax
	je	SHORT $LL261@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN146@match:
	pop	edi
	pop	esi
	pop	ebp

; 3285 :             RRETURN(MATCH_NOMATCH);
; 3286 :         break;
; 3287 : 
; 3288 :         default:
; 3289 :         RRETURN(PCRE_ERROR_INTERNAL);

	mov	eax, -14				; fffffff2H
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN939@match:

; 3302 :       {
; 3303 : #ifdef SUPPORT_UCP
; 3304 :       if (prop_type >= 0)
; 3305 :         {
; 3306 :         switch(prop_type)
; 3307 :           {
; 3308 :           case PT_ANY:
; 3309 :           for (fi = min;; fi++)
; 3310 :             {
; 3311 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
; 3312 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3313 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3314 :             GETCHARINC(c, eptr);
; 3315 :             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
; 3316 :             }
; 3317 :           /* Control never gets here */
; 3318 : 
; 3319 :           case PT_LAMP:
; 3320 :           for (fi = min;; fi++)
; 3321 :             {
; 3322 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
; 3323 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3324 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3325 :             GETCHARINC(c, eptr);
; 3326 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3327 :             if ((prop_chartype == ucp_Lu ||
; 3328 :                  prop_chartype == ucp_Ll ||
; 3329 :                  prop_chartype == ucp_Lt) == prop_fail_result)
; 3330 :               RRETURN(MATCH_NOMATCH);
; 3331 :             }
; 3332 :           /* Control never gets here */
; 3333 : 
; 3334 :           case PT_GC:
; 3335 :           for (fi = min;; fi++)
; 3336 :             {
; 3337 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
; 3338 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3339 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3340 :             GETCHARINC(c, eptr);
; 3341 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3342 :             if ((prop_category == prop_value) == prop_fail_result)
; 3343 :               RRETURN(MATCH_NOMATCH);
; 3344 :             }
; 3345 :           /* Control never gets here */
; 3346 : 
; 3347 :           case PT_PC:
; 3348 :           for (fi = min;; fi++)
; 3349 :             {
; 3350 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
; 3351 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3352 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3353 :             GETCHARINC(c, eptr);
; 3354 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3355 :             if ((prop_chartype == prop_value) == prop_fail_result)
; 3356 :               RRETURN(MATCH_NOMATCH);
; 3357 :             }
; 3358 :           /* Control never gets here */
; 3359 : 
; 3360 :           case PT_SC:
; 3361 :           for (fi = min;; fi++)
; 3362 :             {
; 3363 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
; 3364 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3365 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3366 :             GETCHARINC(c, eptr);
; 3367 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3368 :             if ((prop_script == prop_value) == prop_fail_result)
; 3369 :               RRETURN(MATCH_NOMATCH);
; 3370 :             }
; 3371 :           /* Control never gets here */
; 3372 : 
; 3373 :           default:
; 3374 :           RRETURN(PCRE_ERROR_INTERNAL);
; 3375 :           }
; 3376 :         }
; 3377 : 
; 3378 :       /* Match extended Unicode sequences. We will get here only if the
; 3379 :       support is in the binary; otherwise a compile-time error occurs. */
; 3380 : 
; 3381 :       else if (ctype == OP_EXTUNI)
; 3382 :         {
; 3383 :         for (fi = min;; fi++)
; 3384 :           {
; 3385 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
; 3386 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3387 :           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3388 :           GETCHARINCTEST(c, eptr);
; 3389 :           prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3390 :           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
; 3391 :           while (eptr < md->end_subject)
; 3392 :             {
; 3393 :             int len = 1;
; 3394 :             if (!utf8) c = *eptr; else
; 3395 :               {
; 3396 :               GETCHARLEN(c, eptr, len);
; 3397 :               }
; 3398 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3399 :             if (prop_category != ucp_M) break;
; 3400 :             eptr += len;
; 3401 :             }
; 3402 :           }
; 3403 :         }
; 3404 : 
; 3405 :       else
; 3406 : #endif     /* SUPPORT_UCP */
; 3407 : 
; 3408 : #ifdef SUPPORT_UTF8
; 3409 :       /* UTF-8 mode */
; 3410 :       if (utf8)
; 3411 :         {
; 3412 :         for (fi = min;; fi++)
; 3413 :           {
; 3414 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
; 3415 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3416 :           if (fi >= max || eptr >= md->end_subject ||
; 3417 :                (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&
; 3418 :                 IS_NEWLINE(eptr)))
; 3419 :             RRETURN(MATCH_NOMATCH);
; 3420 : 
; 3421 :           GETCHARINC(c, eptr);
; 3422 :           switch(ctype)
; 3423 :             {
; 3424 :             case OP_ANY:        /* This is the DOTALL case */
; 3425 :             break;
; 3426 : 
; 3427 :             case OP_ANYBYTE:
; 3428 :             break;
; 3429 : 
; 3430 :             case OP_ANYNL:
; 3431 :             switch(c)
; 3432 :               {
; 3433 :               default: RRETURN(MATCH_NOMATCH);
; 3434 :               case 0x000d:
; 3435 :               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
; 3436 :               break;
; 3437 :               case 0x000a:
; 3438 :               break;
; 3439 : 
; 3440 :               case 0x000b:
; 3441 :               case 0x000c:
; 3442 :               case 0x0085:
; 3443 :               case 0x2028:
; 3444 :               case 0x2029:
; 3445 :               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
; 3446 :               break;
; 3447 :               }
; 3448 :             break;
; 3449 : 
; 3450 :             case OP_NOT_HSPACE:
; 3451 :             switch(c)
; 3452 :               {
; 3453 :               default: break;
; 3454 :               case 0x09:      /* HT */
; 3455 :               case 0x20:      /* SPACE */
; 3456 :               case 0xa0:      /* NBSP */
; 3457 :               case 0x1680:    /* OGHAM SPACE MARK */
; 3458 :               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 3459 :               case 0x2000:    /* EN QUAD */
; 3460 :               case 0x2001:    /* EM QUAD */
; 3461 :               case 0x2002:    /* EN SPACE */
; 3462 :               case 0x2003:    /* EM SPACE */
; 3463 :               case 0x2004:    /* THREE-PER-EM SPACE */
; 3464 :               case 0x2005:    /* FOUR-PER-EM SPACE */
; 3465 :               case 0x2006:    /* SIX-PER-EM SPACE */
; 3466 :               case 0x2007:    /* FIGURE SPACE */
; 3467 :               case 0x2008:    /* PUNCTUATION SPACE */
; 3468 :               case 0x2009:    /* THIN SPACE */
; 3469 :               case 0x200A:    /* HAIR SPACE */
; 3470 :               case 0x202f:    /* NARROW NO-BREAK SPACE */
; 3471 :               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3472 :               case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3473 :               RRETURN(MATCH_NOMATCH);
; 3474 :               }
; 3475 :             break;
; 3476 : 
; 3477 :             case OP_HSPACE:
; 3478 :             switch(c)
; 3479 :               {
; 3480 :               default: RRETURN(MATCH_NOMATCH);
; 3481 :               case 0x09:      /* HT */
; 3482 :               case 0x20:      /* SPACE */
; 3483 :               case 0xa0:      /* NBSP */
; 3484 :               case 0x1680:    /* OGHAM SPACE MARK */
; 3485 :               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 3486 :               case 0x2000:    /* EN QUAD */
; 3487 :               case 0x2001:    /* EM QUAD */
; 3488 :               case 0x2002:    /* EN SPACE */
; 3489 :               case 0x2003:    /* EM SPACE */
; 3490 :               case 0x2004:    /* THREE-PER-EM SPACE */
; 3491 :               case 0x2005:    /* FOUR-PER-EM SPACE */
; 3492 :               case 0x2006:    /* SIX-PER-EM SPACE */
; 3493 :               case 0x2007:    /* FIGURE SPACE */
; 3494 :               case 0x2008:    /* PUNCTUATION SPACE */
; 3495 :               case 0x2009:    /* THIN SPACE */
; 3496 :               case 0x200A:    /* HAIR SPACE */
; 3497 :               case 0x202f:    /* NARROW NO-BREAK SPACE */
; 3498 :               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3499 :               case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3500 :               break;
; 3501 :               }
; 3502 :             break;
; 3503 : 
; 3504 :             case OP_NOT_VSPACE:
; 3505 :             switch(c)
; 3506 :               {
; 3507 :               default: break;
; 3508 :               case 0x0a:      /* LF */
; 3509 :               case 0x0b:      /* VT */
; 3510 :               case 0x0c:      /* FF */
; 3511 :               case 0x0d:      /* CR */
; 3512 :               case 0x85:      /* NEL */
; 3513 :               case 0x2028:    /* LINE SEPARATOR */
; 3514 :               case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3515 :               RRETURN(MATCH_NOMATCH);
; 3516 :               }
; 3517 :             break;
; 3518 : 
; 3519 :             case OP_VSPACE:
; 3520 :             switch(c)
; 3521 :               {
; 3522 :               default: RRETURN(MATCH_NOMATCH);
; 3523 :               case 0x0a:      /* LF */
; 3524 :               case 0x0b:      /* VT */
; 3525 :               case 0x0c:      /* FF */
; 3526 :               case 0x0d:      /* CR */
; 3527 :               case 0x85:      /* NEL */
; 3528 :               case 0x2028:    /* LINE SEPARATOR */
; 3529 :               case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3530 :               break;
; 3531 :               }
; 3532 :             break;
; 3533 : 
; 3534 :             case OP_NOT_DIGIT:
; 3535 :             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
; 3536 :               RRETURN(MATCH_NOMATCH);
; 3537 :             break;
; 3538 : 
; 3539 :             case OP_DIGIT:
; 3540 :             if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
; 3541 :               RRETURN(MATCH_NOMATCH);
; 3542 :             break;
; 3543 : 
; 3544 :             case OP_NOT_WHITESPACE:
; 3545 :             if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
; 3546 :               RRETURN(MATCH_NOMATCH);
; 3547 :             break;
; 3548 : 
; 3549 :             case OP_WHITESPACE:
; 3550 :             if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
; 3551 :               RRETURN(MATCH_NOMATCH);
; 3552 :             break;
; 3553 : 
; 3554 :             case OP_NOT_WORDCHAR:
; 3555 :             if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
; 3556 :               RRETURN(MATCH_NOMATCH);
; 3557 :             break;
; 3558 : 
; 3559 :             case OP_WORDCHAR:
; 3560 :             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
; 3561 :               RRETURN(MATCH_NOMATCH);
; 3562 :             break;
; 3563 : 
; 3564 :             default:
; 3565 :             RRETURN(PCRE_ERROR_INTERNAL);
; 3566 :             }
; 3567 :           }
; 3568 :         }
; 3569 :       else
; 3570 : #endif
; 3571 :       /* Not UTF-8 mode */
; 3572 :         {
; 3573 :         for (fi = min;; fi++)
; 3574 :           {
; 3575 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);

	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset_top$[esp+240]
	mov	DWORD PTR _i$[esp+244], ebx
	mov	ebx, DWORD PTR _rdepth$[esp+240]
	add	ebx, 1
	push	ebx
	push	0
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 3576 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	jne	$LN649@match
	npad	3
$LL1354@match:

; 3577 :           if (fi >= max || eptr >= md->end_subject ||
; 3578 :                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))

	mov	ecx, DWORD PTR _i$[esp+244]
	cmp	ecx, DWORD PTR _max$[esp+244]
	jge	$LN645@match
	mov	eax, DWORD PTR [ebp+88]
	cmp	esi, eax
	jae	$LN645@match
	test	BYTE PTR _ims$[esp+240], 4
	jne	SHORT $LN727@match
	mov	ecx, DWORD PTR [ebp+24]
	test	ecx, ecx
	je	SHORT $LN731@match
	push	0
	lea	edx, DWORD PTR [ebp+28]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	$LN645@match
	jmp	SHORT $LN727@match
$LN731@match:
	mov	ecx, DWORD PTR [ebp+28]
	sub	eax, ecx
	cmp	esi, eax
	ja	SHORT $LN727@match
	mov	al, BYTE PTR [esi]
	cmp	al, BYTE PTR [ebp+32]
	jne	SHORT $LN727@match
	cmp	ecx, 1
	je	$LN645@match
	mov	cl, BYTE PTR [esi+1]
	cmp	cl, BYTE PTR [ebp+33]
	je	$LN645@match
$LN727@match:

; 3579 :             RRETURN(MATCH_NOMATCH);
; 3580 : 
; 3581 :           c = *eptr++;
; 3582 :           switch(ctype)

	mov	ecx, DWORD PTR _ctype$[esp+244]
	movzx	eax, BYTE PTR [esi]
	add	ecx, -6					; fffffffaH
	add	esi, 1
	cmp	ecx, 14					; 0000000eH
	ja	$LN146@match
	jmp	DWORD PTR $LN1438@match[ecx*4]
$LN133@match:

; 3583 :             {
; 3584 :             case OP_ANY:   /* This is the DOTALL case */
; 3585 :             break;
; 3586 : 
; 3587 :             case OP_ANYBYTE:
; 3588 :             break;
; 3589 : 
; 3590 :             case OP_ANYNL:
; 3591 :             switch(c)

	add	eax, -10				; fffffff6H
	cmp	eax, 123				; 0000007bH
	ja	$LN645@match
	movzx	edx, BYTE PTR $LN1246@match[eax]
	jmp	DWORD PTR $LN1439@match[edx*4]
$LN129@match:

; 3592 :               {
; 3593 :               default: RRETURN(MATCH_NOMATCH);
; 3594 :               case 0x000d:
; 3595 :               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;

	cmp	esi, DWORD PTR [ebp+88]
	jae	$LN142@match
	cmp	BYTE PTR [esi], 10			; 0000000aH
	jne	$LN142@match
	add	esi, 1

; 3596 :               break;

	jmp	$LN142@match
$LN126@match:

; 3597 : 
; 3598 :               case 0x000a:
; 3599 :               break;
; 3600 : 
; 3601 :               case 0x000b:
; 3602 :               case 0x000c:
; 3603 :               case 0x0085:
; 3604 :               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);

	cmp	DWORD PTR [ebp+76], 0
	jne	$LN645@match

; 3605 :               break;
; 3606 :               }
; 3607 :             break;

	jmp	$LN142@match
$LN124@match:

; 3608 : 
; 3609 :             case OP_NOT_HSPACE:
; 3610 :             switch(c)

	cmp	eax, 9
	je	$LN645@match
	cmp	eax, 32					; 00000020H
	je	$LN645@match
	cmp	eax, 160				; 000000a0H

; 3611 :               {
; 3612 :               default: break;
; 3613 :               case 0x09:      /* HT */
; 3614 :               case 0x20:      /* SPACE */
; 3615 :               case 0xa0:      /* NBSP */
; 3616 :               RRETURN(MATCH_NOMATCH);
; 3617 :               }
; 3618 :             break;

	jmp	$LN1431@match
$LN119@match:

; 3619 : 
; 3620 :             case OP_HSPACE:
; 3621 :             switch(c)

	cmp	eax, 9
	je	$LN142@match
	cmp	eax, 32					; 00000020H
	je	$LN142@match
	cmp	eax, 160				; 000000a0H
	jne	$LN645@match

; 3622 :               {
; 3623 :               default: RRETURN(MATCH_NOMATCH);
; 3624 :               case 0x09:      /* HT */
; 3625 :               case 0x20:      /* SPACE */
; 3626 :               case 0xa0:      /* NBSP */
; 3627 :               break;
; 3628 :               }
; 3629 :             break;

	jmp	$LN142@match
$LN114@match:

; 3630 : 
; 3631 :             case OP_NOT_VSPACE:
; 3632 :             switch(c)

	cmp	eax, 10					; 0000000aH
	jb	$LN142@match
	cmp	eax, 13					; 0000000dH
	jbe	$LN645@match
	cmp	eax, 133				; 00000085H

; 3633 :               {
; 3634 :               default: break;
; 3635 :               case 0x0a:      /* LF */
; 3636 :               case 0x0b:      /* VT */
; 3637 :               case 0x0c:      /* FF */
; 3638 :               case 0x0d:      /* CR */
; 3639 :               case 0x85:      /* NEL */
; 3640 :               RRETURN(MATCH_NOMATCH);
; 3641 :               }
; 3642 :             break;

	jmp	$LN1431@match
$LN109@match:

; 3643 : 
; 3644 :             case OP_VSPACE:
; 3645 :             switch(c)

	cmp	eax, 10					; 0000000aH
	jb	$LN645@match
	cmp	eax, 13					; 0000000dH
	jbe	$LN142@match
	cmp	eax, 133				; 00000085H
	jne	$LN645@match

; 3646 :               {
; 3647 :               default: RRETURN(MATCH_NOMATCH);
; 3648 :               case 0x0a:      /* LF */
; 3649 :               case 0x0b:      /* VT */
; 3650 :               case 0x0c:      /* FF */
; 3651 :               case 0x0d:      /* CR */
; 3652 :               case 0x85:      /* NEL */
; 3653 :               break;
; 3654 :               }
; 3655 :             break;

	jmp	SHORT $LN142@match
$LN104@match:

; 3656 : 
; 3657 :             case OP_NOT_DIGIT:
; 3658 :             if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [eax+ecx], 4
	jne	$LN645@match

; 3659 :             break;

	jmp	SHORT $LN142@match
$LN102@match:

; 3660 : 
; 3661 :             case OP_DIGIT:
; 3662 :             if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);

	mov	edx, DWORD PTR [ebp+40]
	test	BYTE PTR [eax+edx], 4

; 3663 :             break;

	jmp	SHORT $LN1431@match
$LN100@match:

; 3664 : 
; 3665 :             case OP_NOT_WHITESPACE:
; 3666 :             if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [eax+ecx], 1
	jne	$LN645@match

; 3667 :             break;

	jmp	SHORT $LN142@match
$LN98@match:

; 3668 : 
; 3669 :             case OP_WHITESPACE:
; 3670 :             if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);

	mov	edx, DWORD PTR [ebp+40]
	test	BYTE PTR [eax+edx], 1

; 3671 :             break;

	jmp	SHORT $LN1431@match
$LN96@match:

; 3672 : 
; 3673 :             case OP_NOT_WORDCHAR:
; 3674 :             if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);

	mov	ecx, DWORD PTR [ebp+40]
	test	BYTE PTR [eax+ecx], 16			; 00000010H
	jne	$LN645@match

; 3675 :             break;

	jmp	SHORT $LN142@match
$LN94@match:

; 3676 : 
; 3677 :             case OP_WORDCHAR:
; 3678 :             if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);

	mov	edx, DWORD PTR [ebp+40]
	test	BYTE PTR [eax+edx], 16			; 00000010H
$LN1431@match:
	je	$LN645@match
$LN142@match:

; 3302 :       {
; 3303 : #ifdef SUPPORT_UCP
; 3304 :       if (prop_type >= 0)
; 3305 :         {
; 3306 :         switch(prop_type)
; 3307 :           {
; 3308 :           case PT_ANY:
; 3309 :           for (fi = min;; fi++)
; 3310 :             {
; 3311 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
; 3312 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3313 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3314 :             GETCHARINC(c, eptr);
; 3315 :             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
; 3316 :             }
; 3317 :           /* Control never gets here */
; 3318 : 
; 3319 :           case PT_LAMP:
; 3320 :           for (fi = min;; fi++)
; 3321 :             {
; 3322 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
; 3323 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3324 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3325 :             GETCHARINC(c, eptr);
; 3326 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3327 :             if ((prop_chartype == ucp_Lu ||
; 3328 :                  prop_chartype == ucp_Ll ||
; 3329 :                  prop_chartype == ucp_Lt) == prop_fail_result)
; 3330 :               RRETURN(MATCH_NOMATCH);
; 3331 :             }
; 3332 :           /* Control never gets here */
; 3333 : 
; 3334 :           case PT_GC:
; 3335 :           for (fi = min;; fi++)
; 3336 :             {
; 3337 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
; 3338 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3339 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3340 :             GETCHARINC(c, eptr);
; 3341 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3342 :             if ((prop_category == prop_value) == prop_fail_result)
; 3343 :               RRETURN(MATCH_NOMATCH);
; 3344 :             }
; 3345 :           /* Control never gets here */
; 3346 : 
; 3347 :           case PT_PC:
; 3348 :           for (fi = min;; fi++)
; 3349 :             {
; 3350 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
; 3351 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3352 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3353 :             GETCHARINC(c, eptr);
; 3354 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3355 :             if ((prop_chartype == prop_value) == prop_fail_result)
; 3356 :               RRETURN(MATCH_NOMATCH);
; 3357 :             }
; 3358 :           /* Control never gets here */
; 3359 : 
; 3360 :           case PT_SC:
; 3361 :           for (fi = min;; fi++)
; 3362 :             {
; 3363 :             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
; 3364 :             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3365 :             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3366 :             GETCHARINC(c, eptr);
; 3367 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3368 :             if ((prop_script == prop_value) == prop_fail_result)
; 3369 :               RRETURN(MATCH_NOMATCH);
; 3370 :             }
; 3371 :           /* Control never gets here */
; 3372 : 
; 3373 :           default:
; 3374 :           RRETURN(PCRE_ERROR_INTERNAL);
; 3375 :           }
; 3376 :         }
; 3377 : 
; 3378 :       /* Match extended Unicode sequences. We will get here only if the
; 3379 :       support is in the binary; otherwise a compile-time error occurs. */
; 3380 : 
; 3381 :       else if (ctype == OP_EXTUNI)
; 3382 :         {
; 3383 :         for (fi = min;; fi++)
; 3384 :           {
; 3385 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
; 3386 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3387 :           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
; 3388 :           GETCHARINCTEST(c, eptr);
; 3389 :           prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3390 :           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
; 3391 :           while (eptr < md->end_subject)
; 3392 :             {
; 3393 :             int len = 1;
; 3394 :             if (!utf8) c = *eptr; else
; 3395 :               {
; 3396 :               GETCHARLEN(c, eptr, len);
; 3397 :               }
; 3398 :             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
; 3399 :             if (prop_category != ucp_M) break;
; 3400 :             eptr += len;
; 3401 :             }
; 3402 :           }
; 3403 :         }
; 3404 : 
; 3405 :       else
; 3406 : #endif     /* SUPPORT_UCP */
; 3407 : 
; 3408 : #ifdef SUPPORT_UTF8
; 3409 :       /* UTF-8 mode */
; 3410 :       if (utf8)
; 3411 :         {
; 3412 :         for (fi = min;; fi++)
; 3413 :           {
; 3414 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
; 3415 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
; 3416 :           if (fi >= max || eptr >= md->end_subject ||
; 3417 :                (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&
; 3418 :                 IS_NEWLINE(eptr)))
; 3419 :             RRETURN(MATCH_NOMATCH);
; 3420 : 
; 3421 :           GETCHARINC(c, eptr);
; 3422 :           switch(ctype)
; 3423 :             {
; 3424 :             case OP_ANY:        /* This is the DOTALL case */
; 3425 :             break;
; 3426 : 
; 3427 :             case OP_ANYBYTE:
; 3428 :             break;
; 3429 : 
; 3430 :             case OP_ANYNL:
; 3431 :             switch(c)
; 3432 :               {
; 3433 :               default: RRETURN(MATCH_NOMATCH);
; 3434 :               case 0x000d:
; 3435 :               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
; 3436 :               break;
; 3437 :               case 0x000a:
; 3438 :               break;
; 3439 : 
; 3440 :               case 0x000b:
; 3441 :               case 0x000c:
; 3442 :               case 0x0085:
; 3443 :               case 0x2028:
; 3444 :               case 0x2029:
; 3445 :               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
; 3446 :               break;
; 3447 :               }
; 3448 :             break;
; 3449 : 
; 3450 :             case OP_NOT_HSPACE:
; 3451 :             switch(c)
; 3452 :               {
; 3453 :               default: break;
; 3454 :               case 0x09:      /* HT */
; 3455 :               case 0x20:      /* SPACE */
; 3456 :               case 0xa0:      /* NBSP */
; 3457 :               case 0x1680:    /* OGHAM SPACE MARK */
; 3458 :               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 3459 :               case 0x2000:    /* EN QUAD */
; 3460 :               case 0x2001:    /* EM QUAD */
; 3461 :               case 0x2002:    /* EN SPACE */
; 3462 :               case 0x2003:    /* EM SPACE */
; 3463 :               case 0x2004:    /* THREE-PER-EM SPACE */
; 3464 :               case 0x2005:    /* FOUR-PER-EM SPACE */
; 3465 :               case 0x2006:    /* SIX-PER-EM SPACE */
; 3466 :               case 0x2007:    /* FIGURE SPACE */
; 3467 :               case 0x2008:    /* PUNCTUATION SPACE */
; 3468 :               case 0x2009:    /* THIN SPACE */
; 3469 :               case 0x200A:    /* HAIR SPACE */
; 3470 :               case 0x202f:    /* NARROW NO-BREAK SPACE */
; 3471 :               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3472 :               case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3473 :               RRETURN(MATCH_NOMATCH);
; 3474 :               }
; 3475 :             break;
; 3476 : 
; 3477 :             case OP_HSPACE:
; 3478 :             switch(c)
; 3479 :               {
; 3480 :               default: RRETURN(MATCH_NOMATCH);
; 3481 :               case 0x09:      /* HT */
; 3482 :               case 0x20:      /* SPACE */
; 3483 :               case 0xa0:      /* NBSP */
; 3484 :               case 0x1680:    /* OGHAM SPACE MARK */
; 3485 :               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
; 3486 :               case 0x2000:    /* EN QUAD */
; 3487 :               case 0x2001:    /* EM QUAD */
; 3488 :               case 0x2002:    /* EN SPACE */
; 3489 :               case 0x2003:    /* EM SPACE */
; 3490 :               case 0x2004:    /* THREE-PER-EM SPACE */
; 3491 :               case 0x2005:    /* FOUR-PER-EM SPACE */
; 3492 :               case 0x2006:    /* SIX-PER-EM SPACE */
; 3493 :               case 0x2007:    /* FIGURE SPACE */
; 3494 :               case 0x2008:    /* PUNCTUATION SPACE */
; 3495 :               case 0x2009:    /* THIN SPACE */
; 3496 :               case 0x200A:    /* HAIR SPACE */
; 3497 :               case 0x202f:    /* NARROW NO-BREAK SPACE */
; 3498 :               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
; 3499 :               case 0x3000:    /* IDEOGRAPHIC SPACE */
; 3500 :               break;
; 3501 :               }
; 3502 :             break;
; 3503 : 
; 3504 :             case OP_NOT_VSPACE:
; 3505 :             switch(c)
; 3506 :               {
; 3507 :               default: break;
; 3508 :               case 0x0a:      /* LF */
; 3509 :               case 0x0b:      /* VT */
; 3510 :               case 0x0c:      /* FF */
; 3511 :               case 0x0d:      /* CR */
; 3512 :               case 0x85:      /* NEL */
; 3513 :               case 0x2028:    /* LINE SEPARATOR */
; 3514 :               case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3515 :               RRETURN(MATCH_NOMATCH);
; 3516 :               }
; 3517 :             break;
; 3518 : 
; 3519 :             case OP_VSPACE:
; 3520 :             switch(c)
; 3521 :               {
; 3522 :               default: RRETURN(MATCH_NOMATCH);
; 3523 :               case 0x0a:      /* LF */
; 3524 :               case 0x0b:      /* VT */
; 3525 :               case 0x0c:      /* FF */
; 3526 :               case 0x0d:      /* CR */
; 3527 :               case 0x85:      /* NEL */
; 3528 :               case 0x2028:    /* LINE SEPARATOR */
; 3529 :               case 0x2029:    /* PARAGRAPH SEPARATOR */
; 3530 :               break;
; 3531 :               }
; 3532 :             break;
; 3533 : 
; 3534 :             case OP_NOT_DIGIT:
; 3535 :             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
; 3536 :               RRETURN(MATCH_NOMATCH);
; 3537 :             break;
; 3538 : 
; 3539 :             case OP_DIGIT:
; 3540 :             if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
; 3541 :               RRETURN(MATCH_NOMATCH);
; 3542 :             break;
; 3543 : 
; 3544 :             case OP_NOT_WHITESPACE:
; 3545 :             if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
; 3546 :               RRETURN(MATCH_NOMATCH);
; 3547 :             break;
; 3548 : 
; 3549 :             case OP_WHITESPACE:
; 3550 :             if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
; 3551 :               RRETURN(MATCH_NOMATCH);
; 3552 :             break;
; 3553 : 
; 3554 :             case OP_NOT_WORDCHAR:
; 3555 :             if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
; 3556 :               RRETURN(MATCH_NOMATCH);
; 3557 :             break;
; 3558 : 
; 3559 :             case OP_WORDCHAR:
; 3560 :             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
; 3561 :               RRETURN(MATCH_NOMATCH);
; 3562 :             break;
; 3563 : 
; 3564 :             default:
; 3565 :             RRETURN(PCRE_ERROR_INTERNAL);
; 3566 :             }
; 3567 :           }
; 3568 :         }
; 3569 :       else
; 3570 : #endif
; 3571 :       /* Not UTF-8 mode */
; 3572 :         {
; 3573 :         for (fi = min;; fi++)
; 3574 :           {
; 3575 :           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);

	mov	eax, DWORD PTR _eptrb$[esp+240]
	mov	ecx, DWORD PTR _ims$[esp+240]
	mov	edx, DWORD PTR _offset_top$[esp+240]
	add	DWORD PTR _i$[esp+244], 1
	push	ebx
	push	0
	push	eax
	mov	eax, DWORD PTR _mstart$[esp+252]
	push	ecx
	push	ebp
	push	edx
	push	eax
	push	edi
	push	esi
	call	_match
	add	esp, 36					; 00000024H

; 3576 :           if (rrc != MATCH_NOMATCH) RRETURN(rrc);

	test	eax, eax
	je	$LL1354@match
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
$LN91@match:

; 4218 :       }
; 4219 :     /* Control never gets here */
; 4220 : 
; 4221 :     /* There's been some horrible disaster. Arrival here can only mean there is
; 4222 :     something seriously wrong in the code above or the OP_xxx definitions. */
; 4223 : 
; 4224 :     default:
; 4225 :     DPRINTF(("Unknown opcode %d\n", *ecode));
; 4226 :     RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);

	mov	eax, -5					; fffffffbH
$LN649@match:
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 4227 :     }
; 4228 : 
; 4229 :   /* Do not stick any code in here without much thought; it is assumed
; 4230 :   that "continue" in the code above comes out to here to repeat the main
; 4231 :   loop. */
; 4232 : 
; 4233 :   }             /* End of main loop */
; 4234 : /* Control never reaches here */
; 4235 : 
; 4236 : 
; 4237 : /* When compiling to use the heap rather than the stack for recursive calls to
; 4238 : match(), the RRETURN() macro jumps here. The number that is saved in
; 4239 : frame->Xwhere indicates which label we actually want to return to. */
; 4240 : 
; 4241 : #ifdef NO_RECURSE
; 4242 : #define LBL(val) case val: goto L_RM##val;
; 4243 : HEAP_RETURN:
; 4244 : switch (frame->Xwhere)
; 4245 :   {
; 4246 :   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
; 4247 :   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
; 4248 :   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
; 4249 :   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
; 4250 :   LBL(53) LBL(54)
; 4251 : #ifdef SUPPORT_UTF8
; 4252 :   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
; 4253 :   LBL(32) LBL(34) LBL(42) LBL(46)
; 4254 : #ifdef SUPPORT_UCP
; 4255 :   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
; 4256 : #endif  /* SUPPORT_UCP */
; 4257 : #endif  /* SUPPORT_UTF8 */
; 4258 :   default:
; 4259 :   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
; 4260 :   return PCRE_ERROR_INTERNAL;
; 4261 :   }
; 4262 : #undef LBL
; 4263 : #endif  /* NO_RECURSE */
; 4264 : }

	add	esp, 228				; 000000e4H
	ret	0
	npad	3
$LN1432@match:
	DD	$LN606@match
	DD	$LN515@match
	DD	$LN510@match
	DD	$LN508@match
	DD	$LN491@match
	DD	$LN480@match
	DD	$LN477@match
	DD	$LN474@match
	DD	$LN471@match
	DD	$LN468@match
	DD	$LN465@match
	DD	$LN489@match
	DD	$LN482@match
	DD	$LN462@match
	DD	$LN452@match
	DD	$LN446@match
	DD	$LN440@match
	DD	$LN434@match
	DD	$LN494@match
	DD	$LN499@match
	DD	$LN603@match
	DD	$LN519@match
	DD	$LN507@match
	DD	$LN376@match
	DD	$LN364@match
	DD	$LN316@match
	DD	$LN355@match
	DD	$LN359@match
	DD	$LN361@match
	DD	$LN358@match
	DD	$LN357@match
	DD	$LN356@match
	DD	$LN360@match
	DD	$LN294@match
	DD	$LN299@match
	DD	$LN300@match
	DD	$LN298@match
	DD	$LN297@match
	DD	$LN296@match
	DD	$LN295@match
	DD	$LN239@match
	DD	$LN244@match
	DD	$LN255@match
	DD	$LN243@match
	DD	$LN242@match
	DD	$LN241@match
	DD	$LN240@match
	DD	$LN406@match
	DD	$LN428@match
	DD	$LN578@match
	DD	$LN582@match
	DD	$LL548@match
	DD	$LN535@match
	DD	$LN1117@match
	DD	$LN1119@match
	DD	$LN584@match
	DD	$LN566@match
	DD	$LN635@match
	DD	$LN636@match
	DD	$LN628@match
	DD	$LN545@match
	DD	$LN540@match
	DD	$LN644@match
	DD	$LN640@match
	DD	$LN638@match
	DD	$LN642@match
	DD	$LN645@match
	DD	$LN91@match
$LN1242@match:
	DB	0
	DB	1
	DB	2
	DB	3
	DB	4
	DB	4
	DB	5
	DB	6
	DB	7
	DB	8
	DB	9
	DB	10					; 0000000aH
	DB	11					; 0000000bH
	DB	12					; 0000000cH
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	13					; 0000000dH
	DB	14					; 0000000eH
	DB	15					; 0000000fH
	DB	16					; 00000010H
	DB	17					; 00000011H
	DB	67					; 00000043H
	DB	18					; 00000012H
	DB	19					; 00000013H
	DB	20					; 00000014H
	DB	21					; 00000015H
	DB	22					; 00000016H
	DB	23					; 00000017H
	DB	24					; 00000018H
	DB	25					; 00000019H
	DB	26					; 0000001aH
	DB	26					; 0000001aH
	DB	26					; 0000001aH
	DB	26					; 0000001aH
	DB	26					; 0000001aH
	DB	26					; 0000001aH
	DB	27					; 0000001bH
	DB	27					; 0000001bH
	DB	28					; 0000001cH
	DB	29					; 0000001dH
	DB	30					; 0000001eH
	DB	31					; 0000001fH
	DB	32					; 00000020H
	DB	33					; 00000021H
	DB	33					; 00000021H
	DB	33					; 00000021H
	DB	33					; 00000021H
	DB	33					; 00000021H
	DB	33					; 00000021H
	DB	34					; 00000022H
	DB	34					; 00000022H
	DB	35					; 00000023H
	DB	36					; 00000024H
	DB	37					; 00000025H
	DB	38					; 00000026H
	DB	39					; 00000027H
	DB	40					; 00000028H
	DB	40					; 00000028H
	DB	40					; 00000028H
	DB	40					; 00000028H
	DB	40					; 00000028H
	DB	40					; 00000028H
	DB	41					; 00000029H
	DB	41					; 00000029H
	DB	42					; 0000002aH
	DB	43					; 0000002bH
	DB	44					; 0000002cH
	DB	45					; 0000002dH
	DB	46					; 0000002eH
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	47					; 0000002fH
	DB	47					; 0000002fH
	DB	67					; 00000043H
	DB	48					; 00000030H
	DB	49					; 00000031H
	DB	50					; 00000032H
	DB	51					; 00000033H
	DB	52					; 00000034H
	DB	52					; 00000034H
	DB	52					; 00000034H
	DB	53					; 00000035H
	DB	54					; 00000036H
	DB	53					; 00000035H
	DB	54					; 00000036H
	DB	55					; 00000037H
	DB	56					; 00000038H
	DB	57					; 00000039H
	DB	58					; 0000003aH
	DB	59					; 0000003bH
	DB	57					; 00000039H
	DB	58					; 0000003aH
	DB	59					; 0000003bH
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	67					; 00000043H
	DB	60					; 0000003cH
	DB	61					; 0000003dH
	DB	62					; 0000003eH
	DB	63					; 0000003fH
	DB	64					; 00000040H
	DB	65					; 00000041H
	DB	66					; 00000042H
	DB	0
	npad	2
$LN1433@match:
	DD	$LN425@match
	DD	$LN423@match
$LN1243@match:
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	1
	DB	1
$LN1434@match:
	DD	$LN395@match
	DD	$LN393@match
$LN1244@match:
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	1
	DB	1
$LN1435@match:
	DD	$LN176@match
	DD	$LN171@match
	DD	$LN166@match
	DD	$LN161@match
	DD	$LN156@match
	DD	$LN151@match
	DD	$LN233@match
	DD	$LN232@match
	DD	$LN146@match
	DD	$LN146@match
	DD	$LN225@match
	DD	$LN212@match
	DD	$LN203@match
	DD	$LN194@match
	DD	$LN185@match
$LN1436@match:
	DD	$LN223@match
	DD	$LN214@match
	DD	$LN217@match
	DD	$LN645@match
$LN1245@match:
	DB	0
	DB	1
	DB	1
	DB	2
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	1
$LN1437@match:
	DD	$LN42@match
	DD	$LN36@match
	DD	$LN30@match
	DD	$LN24@match
	DD	$LN18@match
	DD	$LN12@match
	DD	$LN88@match
	DD	$LN1312@match
	DD	$LN146@match
	DD	$LN146@match
	DD	$LN79@match
	DD	$LN68@match
	DD	$LN61@match
	DD	$LN55@match
	DD	$LN48@match
$LN1438@match:
	DD	$LN104@match
	DD	$LN102@match
	DD	$LN100@match
	DD	$LN98@match
	DD	$LN96@match
	DD	$LN94@match
	DD	$LN142@match
	DD	$LN142@match
	DD	$LN146@match
	DD	$LN146@match
	DD	$LN133@match
	DD	$LN124@match
	DD	$LN119@match
	DD	$LN114@match
	DD	$LN109@match
$LN1439@match:
	DD	$LN142@match
	DD	$LN126@match
	DD	$LN129@match
	DD	$LN645@match
$LN1246@match:
	DB	0
	DB	1
	DB	1
	DB	2
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	1
_match	ENDP
_TEXT	ENDS
PUBLIC	_pcre_exec
EXTRN	__pcre_try_flipped:PROC
EXTRN	__pcre_default_tables:BYTE
; Function compile flags: /Ogtpy
;	COMDAT _pcre_exec
_TEXT	SEGMENT
_end_subject$ = -280					; size = 4
_flags$6223 = -280					; size = 4
_save_end_subject$6293 = -276				; size = 4
_tables$ = -276						; size = 4
_first_byte$ = -272					; size = 4
_study$ = -268						; size = 4
_re$ = -264						; size = 4
_utf8$ = -260						; size = 4
_using_temporary_offsets$ = -256			; size = 4
_resetcount$ = -252					; size = 4
_match_block$ = -248					; size = 128
_start_bits$ = -120					; size = 4
_firstline$ = -116					; size = 4
_first_byte_caseless$ = -112				; size = 4
_anchored$ = -108					; size = 4
_req_byte_caseless$ = -104				; size = 4
_req_byte$ = -100					; size = 4
_req_byte2$ = -96					; size = 4
_startline$ = -92					; size = 4
_req_byte_ptr$ = -88					; size = 4
_ims$ = -84						; size = 4
_internal_study$ = -80					; size = 40
_internal_re$ = -40					; size = 40
_argument_re$ = 8					; size = 4
_extra_data$ = 12					; size = 4
_subject$ = 16						; size = 4
_length$ = 20						; size = 4
_start_offset$ = 24					; size = 4
_options$ = 28						; size = 4
_offsets$ = 32						; size = 4
_offsetcount$ = 36					; size = 4
_pcre_exec PROC						; COMDAT

; 4353 : {

	sub	esp, 280				; 00000118H
	push	ebx

; 4354 : int rc, resetcount, ocount;
; 4355 : int first_byte = -1;
; 4356 : int req_byte = -1;
; 4357 : int req_byte2 = -1;
; 4358 : int newline;
; 4359 : unsigned long int ims;
; 4360 : BOOL using_temporary_offsets = FALSE;
; 4361 : BOOL anchored;
; 4362 : BOOL startline;
; 4363 : BOOL firstline;
; 4364 : BOOL first_byte_caseless = FALSE;
; 4365 : BOOL req_byte_caseless = FALSE;
; 4366 : BOOL utf8;
; 4367 : match_data match_block;
; 4368 : match_data *md = &match_block;
; 4369 : const uschar *tables;
; 4370 : const uschar *start_bits = NULL;
; 4371 : USPTR start_match = (USPTR)subject + start_offset;
; 4372 : USPTR end_subject;
; 4373 : USPTR req_byte_ptr = start_match - 1;
; 4374 : 
; 4375 : pcre_study_data internal_study;
; 4376 : const pcre_study_data *study;
; 4377 : 
; 4378 : real_pcre internal_re;
; 4379 : const real_pcre *external_re = (const real_pcre *)argument_re;
; 4380 : const real_pcre *re = external_re;

	mov	ebx, DWORD PTR _argument_re$[esp+280]
	push	ebp
	or	eax, -1
	push	esi

; 4381 : 
; 4382 : /* Plausibility checks */
; 4383 : 
; 4384 : if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;

	mov	esi, DWORD PTR _options$[esp+288]
	push	edi
	mov	edi, DWORD PTR _subject$[esp+292]
	mov	DWORD PTR _first_byte$[esp+296], eax
	mov	DWORD PTR _req_byte$[esp+296], eax
	mov	DWORD PTR _req_byte2$[esp+296], eax
	mov	eax, DWORD PTR _start_offset$[esp+292]
	xor	ecx, ecx
	test	esi, -32548241				; fe0f5a6fH
	lea	ebp, DWORD PTR [edi+eax]
	lea	edx, DWORD PTR [ebp-1]
	mov	DWORD PTR _using_temporary_offsets$[esp+296], ecx
	mov	DWORD PTR _first_byte_caseless$[esp+296], ecx
	mov	DWORD PTR _req_byte_caseless$[esp+296], ecx
	mov	DWORD PTR _start_bits$[esp+296], ecx
	mov	DWORD PTR _req_byte_ptr$[esp+296], edx
	mov	DWORD PTR _re$[esp+296], ebx
	je	SHORT $LN113@pcre_exec
	pop	edi
	pop	esi
	pop	ebp
	lea	eax, DWORD PTR [ecx-3]
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN113@pcre_exec:

; 4385 : if (re == NULL || subject == NULL ||
; 4386 :    (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;

	cmp	ebx, ecx
	je	$LN111@pcre_exec
	cmp	edi, ecx
	je	$LN111@pcre_exec
	cmp	DWORD PTR _offsets$[esp+292], ecx
	mov	eax, DWORD PTR _offsetcount$[esp+292]
	jne	SHORT $LN112@pcre_exec
	cmp	eax, ecx
	jg	$LN111@pcre_exec
$LN112@pcre_exec:

; 4387 : if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;

	cmp	eax, ecx
	jge	SHORT $LN110@pcre_exec
	pop	edi
	pop	esi
	pop	ebp
	mov	eax, -15				; fffffff1H
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN110@pcre_exec:

; 4388 : 
; 4389 : /* Fish out the optional data from the extra_data structure, first setting
; 4390 : the default values. */
; 4391 : 
; 4392 : study = NULL;
; 4393 : md->match_limit = MATCH_LIMIT;

	mov	eax, 10000000				; 00989680H
	mov	DWORD PTR _match_block$[esp+300], eax

; 4394 : md->match_limit_recursion = MATCH_LIMIT_RECURSION;

	mov	DWORD PTR _match_block$[esp+304], eax

; 4395 : md->callout_data = NULL;
; 4396 : 
; 4397 : /* The table pointer is always in native byte order. */
; 4398 : 
; 4399 : tables = external_re->tables;

	mov	eax, DWORD PTR [ebx+32]
	mov	DWORD PTR _tables$[esp+296], eax

; 4400 : 
; 4401 : if (extra_data != NULL)

	mov	eax, DWORD PTR _extra_data$[esp+292]
	cmp	eax, ecx
	mov	DWORD PTR _study$[esp+296], ecx
	mov	DWORD PTR _match_block$[esp+420], ecx
	je	SHORT $LN229@pcre_exec

; 4402 :   {
; 4403 :   register unsigned int flags = extra_data->flags;

	mov	edx, DWORD PTR [eax]

; 4404 :   if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)

	test	dl, 1
	mov	DWORD PTR _flags$6223[esp+296], edx
	je	SHORT $LN108@pcre_exec

; 4405 :     study = (const pcre_study_data *)extra_data->study_data;

	mov	edx, DWORD PTR [eax+4]
	mov	DWORD PTR _study$[esp+296], edx
	mov	edx, DWORD PTR _flags$6223[esp+296]
$LN108@pcre_exec:

; 4406 :   if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)

	test	dl, 2
	je	SHORT $LN107@pcre_exec

; 4407 :     md->match_limit = extra_data->match_limit;

	mov	edx, DWORD PTR [eax+8]
	mov	DWORD PTR _match_block$[esp+300], edx
	mov	edx, DWORD PTR _flags$6223[esp+296]
$LN107@pcre_exec:

; 4408 :   if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)

	test	dl, 16					; 00000010H
	je	SHORT $LN106@pcre_exec

; 4409 :     md->match_limit_recursion = extra_data->match_limit_recursion;

	mov	edx, DWORD PTR [eax+20]
	mov	DWORD PTR _match_block$[esp+304], edx
	mov	edx, DWORD PTR _flags$6223[esp+296]
$LN106@pcre_exec:

; 4410 :   if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)

	test	dl, 4
	je	SHORT $LN105@pcre_exec

; 4411 :     md->callout_data = extra_data->callout_data;

	mov	edx, DWORD PTR [eax+12]
	mov	DWORD PTR _match_block$[esp+420], edx
	mov	edx, DWORD PTR _flags$6223[esp+296]
$LN105@pcre_exec:

; 4412 :   if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;

	test	dl, 8
	je	SHORT $LN229@pcre_exec
	mov	eax, DWORD PTR [eax+16]
	mov	DWORD PTR _tables$[esp+296], eax
$LN229@pcre_exec:

; 4413 :   }
; 4414 : 
; 4415 : /* If the exec call supplied NULL for tables, use the inbuilt ones. This
; 4416 : is a feature that makes it possible to save compiled regex and re-use them
; 4417 : in other programs later. */
; 4418 : 
; 4419 : if (tables == NULL) tables = _pcre_default_tables;

	cmp	DWORD PTR _tables$[esp+296], ecx
	jne	SHORT $LN103@pcre_exec
	mov	DWORD PTR _tables$[esp+296], OFFSET __pcre_default_tables
$LN103@pcre_exec:

; 4420 : 
; 4421 : /* Check that the first field in the block is the magic number. If it is not,
; 4422 : test for a regex that was compiled on a host of opposite endianness. If this is
; 4423 : the case, flipped values are put in internal_re and internal_study if there was
; 4424 : study data too. */
; 4425 : 
; 4426 : if (re->magic_number != MAGIC_NUMBER)

	cmp	DWORD PTR [ebx], 1346589253		; 50435245H
	je	SHORT $LN226@pcre_exec

; 4427 :   {
; 4428 :   re = _pcre_try_flipped(re, &internal_re, study, &internal_study);

	mov	edx, DWORD PTR _study$[esp+296]
	lea	ecx, DWORD PTR _internal_study$[esp+296]
	push	ecx
	push	edx
	lea	eax, DWORD PTR _internal_re$[esp+304]
	push	eax
	push	ebx
	call	__pcre_try_flipped
	add	esp, 16					; 00000010H

; 4429 :   if (re == NULL) return PCRE_ERROR_BADMAGIC;

	test	eax, eax
	mov	DWORD PTR _re$[esp+296], eax
	jne	SHORT $LN101@pcre_exec
	pop	edi
	pop	esi
	pop	ebp
	mov	eax, -4					; fffffffcH
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN101@pcre_exec:

; 4430 :   if (study != NULL) study = &internal_study;

	cmp	DWORD PTR _study$[esp+296], 0
	je	SHORT $LN226@pcre_exec
	lea	ecx, DWORD PTR _internal_study$[esp+296]
	mov	DWORD PTR _study$[esp+296], ecx
$LN226@pcre_exec:

; 4431 :   }
; 4432 : 
; 4433 : /* Set up other data */
; 4434 : 
; 4435 : anchored = ((re->options | options) & PCRE_ANCHORED) != 0;

	mov	ecx, DWORD PTR _re$[esp+296]
	mov	eax, DWORD PTR [ecx+8]
	mov	edx, eax
	or	edx, esi
	shr	edx, 4
	and	edx, 1

; 4436 : startline = (re->flags & PCRE_STARTLINE) != 0;
; 4437 : firstline = (re->options & PCRE_FIRSTLINE) != 0;

	shr	eax, 18					; 00000012H
	and	eax, 1
	mov	DWORD PTR _anchored$[esp+296], edx
	movzx	edx, BYTE PTR [ecx+12]
	mov	DWORD PTR _firstline$[esp+296], eax

; 4438 : 
; 4439 : /* The code starts after the real_pcre block and the capture name table. */
; 4440 : 
; 4441 : md->start_code = (const uschar *)external_re + re->name_table_offset +
; 4442 :   re->name_count * re->name_entry_size;

	movzx	eax, WORD PTR [ecx+26]
	shr	edx, 3
	and	edx, 1
	mov	DWORD PTR _startline$[esp+296], edx
	movzx	edx, WORD PTR [ecx+28]
	imul	edx, eax
	movzx	eax, WORD PTR [ecx+24]
	add	edx, ebx
	add	eax, edx

; 4443 : 
; 4444 : md->start_subject = (USPTR)subject;
; 4445 : md->start_offset = start_offset;

	mov	edx, DWORD PTR _start_offset$[esp+292]
	mov	DWORD PTR _match_block$[esp+376], eax

; 4446 : md->end_subject = md->start_subject + length;

	mov	eax, DWORD PTR _length$[esp+292]
	lea	ebx, DWORD PTR [edi+eax]
	mov	DWORD PTR _match_block$[esp+404], edx
	mov	DWORD PTR _match_block$[esp+380], edi
	mov	DWORD PTR _match_block$[esp+384], ebx

; 4447 : end_subject = md->end_subject;
; 4448 : 
; 4449 : md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;

	mov	edx, DWORD PTR [ecx+8]
	shr	edx, 5
	and	edx, 1
	mov	DWORD PTR _match_block$[esp+356], edx

; 4450 : utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;

	mov	eax, DWORD PTR [ecx+8]
	shr	eax, 11					; 0000000bH
	and	eax, 1
	mov	DWORD PTR _match_block$[esp+352], eax
	mov	DWORD PTR _utf8$[esp+296], eax

; 4451 : 
; 4452 : md->notbol = (options & PCRE_NOTBOL) != 0;

	mov	eax, esi
	shr	eax, 7
	and	eax, 1
	mov	DWORD PTR _match_block$[esp+344], eax

; 4453 : md->noteol = (options & PCRE_NOTEOL) != 0;
; 4454 : md->notempty = (options & PCRE_NOTEMPTY) != 0;

	mov	eax, esi
	shr	eax, 10					; 0000000aH
	and	eax, 1
	mov	DWORD PTR _match_block$[esp+360], eax

; 4455 : md->partial = (options & PCRE_PARTIAL) != 0;

	mov	eax, esi
	shr	eax, 15					; 0000000fH
	and	eax, 1
	mov	DWORD PTR _match_block$[esp+364], eax

; 4456 : md->hitend = FALSE;
; 4457 : 
; 4458 : md->recursive = NULL;                   /* No recursion at top level */
; 4459 : 
; 4460 : md->lcc = tables + lcc_offset;

	mov	eax, DWORD PTR _tables$[esp+296]
	mov	DWORD PTR _match_block$[esp+332], eax

; 4461 : md->ctypes = tables + ctypes_offset;

	add	eax, 832				; 00000340H
	mov	edx, esi
	shr	edx, 8
	mov	DWORD PTR _match_block$[esp+336], eax
	xor	edi, edi
	and	edx, 1

; 4462 : 
; 4463 : /* Handle different \R options. */
; 4464 : 
; 4465 : switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))

	mov	eax, esi
	and	eax, 25165824				; 01800000H
	mov	DWORD PTR _end_subject$[esp+296], ebx
	mov	DWORD PTR _match_block$[esp+348], edx
	mov	DWORD PTR _match_block$[esp+368], edi
	mov	DWORD PTR _match_block$[esp+416], edi
	je	SHORT $LN97@pcre_exec
	cmp	eax, 8388608				; 00800000H
	je	SHORT $LN94@pcre_exec
	cmp	eax, 16777216				; 01000000H
	je	SHORT $LN96@pcre_exec
$LN83@pcre_exec:
	pop	edi
	pop	esi
	pop	ebp

; 4481 : 
; 4482 :   case PCRE_BSR_UNICODE:
; 4483 :   md->bsr_anycrlf = FALSE;
; 4484 :   break;
; 4485 : 
; 4486 :   default: return PCRE_ERROR_BADNEWLINE;

	mov	eax, -23				; ffffffe9H
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN94@pcre_exec:

; 4475 : #endif
; 4476 :   break;
; 4477 : 
; 4478 :   case PCRE_BSR_ANYCRLF:
; 4479 :   md->bsr_anycrlf = TRUE;

	mov	DWORD PTR _match_block$[esp+372], 1

; 4480 :   break;

	jmp	SHORT $LN95@pcre_exec
$LN97@pcre_exec:

; 4466 :   {
; 4467 :   case 0:
; 4468 :   if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)

	mov	eax, DWORD PTR [ecx+8]
	test	eax, 25165824				; 01800000H
	je	SHORT $LN96@pcre_exec

; 4469 :     md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;

	shr	eax, 23					; 00000017H
	and	eax, 1
	mov	DWORD PTR _match_block$[esp+372], eax

; 4470 :   else

	jmp	SHORT $LN95@pcre_exec
$LN96@pcre_exec:

; 4471 : #ifdef BSR_ANYCRLF
; 4472 :   md->bsr_anycrlf = TRUE;
; 4473 : #else
; 4474 :   md->bsr_anycrlf = FALSE;

	mov	DWORD PTR _match_block$[esp+372], edi
$LN95@pcre_exec:

; 4487 :   }
; 4488 : 
; 4489 : /* Handle different types of newline. The three bits give eight cases. If
; 4490 : nothing is set at run time, whatever was used at compile time applies. */
; 4491 : 
; 4492 : switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
; 4493 :         (pcre_uint32)options) & PCRE_NEWLINE_BITS)

	test	esi, 7340032				; 00700000H
	jne	SHORT $LN116@pcre_exec
	mov	esi, DWORD PTR [ecx+8]
$LN116@pcre_exec:
	and	esi, 7340032				; 00700000H
	cmp	esi, 3145728				; 00300000H
	ja	SHORT $LN118@pcre_exec
	je	SHORT $LN86@pcre_exec
	cmp	esi, edi
	je	SHORT $LN89@pcre_exec
	cmp	esi, 1048576				; 00100000H
	je	SHORT $LN88@pcre_exec
	cmp	esi, 2097152				; 00200000H
	jne	SHORT $LN83@pcre_exec
$LN89@pcre_exec:

; 4497 :   case PCRE_NEWLINE_LF: newline = '\n'; break;

	mov	eax, 10					; 0000000aH
$LN80@pcre_exec:

; 4514 :   {
; 4515 :   md->nltype = NLTYPE_FIXED;
; 4516 :   if (newline > 255)

	cmp	eax, 255				; 000000ffH
	mov	DWORD PTR _match_block$[esp+320], edi
	jle	SHORT $LN78@pcre_exec

; 4517 :     {
; 4518 :     md->nllen = 2;
; 4519 :     md->nl[0] = (newline >> 8) & 255;

	mov	edx, eax
	sar	edx, 8
	mov	DWORD PTR _match_block$[esp+324], 2
	mov	BYTE PTR _match_block$[esp+328], dl

; 4520 :     md->nl[1] = newline & 255;

	mov	BYTE PTR _match_block$[esp+329], al

; 4521 :     }
; 4522 :   else

	jmp	SHORT $LN77@pcre_exec
$LN88@pcre_exec:

; 4494 :   {
; 4495 :   case 0: newline = NEWLINE; break;   /* Compile-time default */
; 4496 :   case PCRE_NEWLINE_CR: newline = '\r'; break;

	mov	eax, 13					; 0000000dH
	jmp	SHORT $LN80@pcre_exec
$LN86@pcre_exec:

; 4498 :   case PCRE_NEWLINE_CR+
; 4499 :        PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;

	mov	eax, 3338				; 00000d0aH
	jmp	SHORT $LN80@pcre_exec
$LN118@pcre_exec:

; 4487 :   }
; 4488 : 
; 4489 : /* Handle different types of newline. The three bits give eight cases. If
; 4490 : nothing is set at run time, whatever was used at compile time applies. */
; 4491 : 
; 4492 : switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
; 4493 :         (pcre_uint32)options) & PCRE_NEWLINE_BITS)

	cmp	esi, 4194304				; 00400000H
	je	SHORT $LN185@pcre_exec
	cmp	esi, 5242880				; 00500000H

; 4500 :   case PCRE_NEWLINE_ANY: newline = -1; break;
; 4501 :   case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
; 4502 :   default: return PCRE_ERROR_BADNEWLINE;

	jne	$LN83@pcre_exec

; 4503 :   }
; 4504 : 
; 4505 : if (newline == -2)
; 4506 :   {
; 4507 :   md->nltype = NLTYPE_ANYCRLF;

	mov	DWORD PTR _match_block$[esp+320], 2
	jmp	SHORT $LN77@pcre_exec
$LN185@pcre_exec:

; 4508 :   }
; 4509 : else if (newline < 0)
; 4510 :   {
; 4511 :   md->nltype = NLTYPE_ANY;

	mov	DWORD PTR _match_block$[esp+320], 1

; 4512 :   }
; 4513 : else

	jmp	SHORT $LN77@pcre_exec
$LN78@pcre_exec:

; 4523 :     {
; 4524 :     md->nllen = 1;

	mov	DWORD PTR _match_block$[esp+324], 1

; 4525 :     md->nl[0] = newline;

	mov	BYTE PTR _match_block$[esp+328], al
$LN77@pcre_exec:

; 4526 :     }
; 4527 :   }
; 4528 : 
; 4529 : /* Partial matching is supported only for a restricted set of regexes at the
; 4530 : moment. */
; 4531 : 
; 4532 : if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)

	cmp	DWORD PTR _match_block$[esp+364], edi
	je	SHORT $LN76@pcre_exec
	test	BYTE PTR [ecx+12], 1
	je	SHORT $LN76@pcre_exec
	pop	edi
	pop	esi
	pop	ebp

; 4533 :   return PCRE_ERROR_BADPARTIAL;

	mov	eax, -13				; fffffff3H
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN76@pcre_exec:

; 4534 : 
; 4535 : /* Check a UTF-8 string if required. Unfortunately there's no way of passing
; 4536 : back the character offset. */
; 4537 : 
; 4538 : #ifdef SUPPORT_UTF8
; 4539 : if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
; 4540 :   {
; 4541 :   if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
; 4542 :     return PCRE_ERROR_BADUTF8;
; 4543 :   if (start_offset > 0 && start_offset < length)
; 4544 :     {
; 4545 :     int tb = ((uschar *)subject)[start_offset];
; 4546 :     if (tb > 127)
; 4547 :       {
; 4548 :       tb &= 0xc0;
; 4549 :       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;
; 4550 :       }
; 4551 :     }
; 4552 :   }
; 4553 : #endif
; 4554 : 
; 4555 : /* The ims options can vary during the matching as a result of the presence
; 4556 : of (?ims) items in the pattern. They are kept in a local variable so that
; 4557 : restoring at the exit of a group is easy. */
; 4558 : 
; 4559 : ims = re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL);

	mov	eax, DWORD PTR [ecx+8]
	and	eax, 7
	mov	DWORD PTR _ims$[esp+296], eax

; 4560 : 
; 4561 : /* If the expression has got more back references than the offsets supplied can
; 4562 : hold, we get a temporary chunk of working store to use during the matching.
; 4563 : Otherwise, we can use the vector supplied, rounding down its size to a multiple
; 4564 : of 3. */
; 4565 : 
; 4566 : ocount = offsetcount - (offsetcount % 3);

	mov	eax, 1431655766				; 55555556H
	imul	DWORD PTR _offsetcount$[esp+292]
	mov	eax, edx
	shr	eax, 31					; 0000001fH
	add	eax, edx
	lea	esi, DWORD PTR [eax+eax*2]

; 4567 : 
; 4568 : if (re->top_backref > 0 && re->top_backref >= ocount/3)

	movzx	eax, WORD PTR [ecx+18]
	cmp	ax, di
	jbe	SHORT $LN75@pcre_exec
	movzx	ecx, ax
	mov	eax, 1431655766				; 55555556H
	imul	esi
	mov	eax, edx
	shr	eax, 31					; 0000001fH
	add	eax, edx
	cmp	ecx, eax
	jl	SHORT $LN75@pcre_exec

; 4569 :   {
; 4570 :   ocount = re->top_backref * 3 + 3;

	lea	esi, DWORD PTR [ecx+ecx*2+3]

; 4571 :   md->offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));

	lea	ecx, DWORD PTR [esi*4]
	push	ecx
	call	DWORD PTR _pcre_malloc
	add	esp, 4

; 4572 :   if (md->offset_vector == NULL) return PCRE_ERROR_NOMEMORY;

	test	eax, eax
	mov	DWORD PTR _match_block$[esp+308], eax
	jne	SHORT $LN74@pcre_exec
	pop	edi
	pop	esi
	pop	ebp
	mov	eax, -6					; fffffffaH
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN74@pcre_exec:

; 4573 :   using_temporary_offsets = TRUE;

	mov	ebx, DWORD PTR _match_block$[esp+384]
	mov	DWORD PTR _using_temporary_offsets$[esp+296], 1
	jmp	SHORT $LN73@pcre_exec
$LN75@pcre_exec:

; 4574 :   DPRINTF(("Got memory to hold back references\n"));
; 4575 :   }
; 4576 : else md->offset_vector = offsets;

	mov	edx, DWORD PTR _offsets$[esp+292]
	mov	DWORD PTR _match_block$[esp+308], edx
$LN73@pcre_exec:

; 4577 : 
; 4578 : md->offset_end = ocount;
; 4579 : md->offset_max = (2*ocount)/3;

	lea	ecx, DWORD PTR [esi+esi]
	mov	eax, 1431655766				; 55555556H
	imul	ecx
	mov	eax, edx
	shr	eax, 31					; 0000001fH
	add	eax, edx

; 4580 : md->offset_overflow = FALSE;

	mov	DWORD PTR _match_block$[esp+340], edi

; 4581 : md->capture_last = -1;
; 4582 : 
; 4583 : /* Compute the minimum number of offsets that we need to reset each time. Doing
; 4584 : this makes a huge difference to execution time when there aren't many brackets
; 4585 : in the pattern. */
; 4586 : 
; 4587 : resetcount = 2 + re->top_bracket * 2;

	mov	edi, DWORD PTR _re$[esp+296]
	mov	DWORD PTR _match_block$[esp+316], eax
	mov	DWORD PTR _match_block$[esp+312], esi
	mov	DWORD PTR _match_block$[esp+400], -1
	movzx	eax, WORD PTR [edi+16]
	lea	eax, DWORD PTR [eax+eax+2]

; 4588 : if (resetcount > offsetcount) resetcount = ocount;

	cmp	eax, DWORD PTR _offsetcount$[esp+292]
	mov	DWORD PTR _resetcount$[esp+296], eax
	jle	SHORT $LN72@pcre_exec
	mov	DWORD PTR _resetcount$[esp+296], esi
$LN72@pcre_exec:

; 4589 : 
; 4590 : /* Reset the working variable associated with each extraction. These should
; 4591 : never be used unless previously set, but they get saved and restored, and so we
; 4592 : initialize them to avoid reading uninitialized locations. */
; 4593 : 
; 4594 : if (md->offset_vector != NULL)

	cmp	DWORD PTR _match_block$[esp+308], 0
	je	SHORT $LN230@pcre_exec

; 4595 :   {
; 4596 :   register int *iptr = md->offset_vector + ocount;
; 4597 :   register int *iend = iptr - resetcount/2 + 1;

	mov	eax, DWORD PTR _resetcount$[esp+296]
	mov	ecx, DWORD PTR _match_block$[esp+308]
	cdq
	sub	eax, edx
	sar	eax, 1
	mov	edx, 1
	lea	ecx, DWORD PTR [ecx+esi*4]
	sub	edx, eax
	lea	eax, DWORD PTR [ecx+edx*4]

; 4598 :   while (--iptr >= iend) *iptr = -1;

	sub	ecx, 4
	cmp	ecx, eax
	jb	SHORT $LN230@pcre_exec
$LL70@pcre_exec:
	mov	DWORD PTR [ecx], -1
	sub	ecx, 4
	cmp	ecx, eax
	jae	SHORT $LL70@pcre_exec
	mov	ebx, DWORD PTR _match_block$[esp+384]
$LN230@pcre_exec:

; 4599 :   }
; 4600 : 
; 4601 : /* Set up the first character to match, if available. The first_byte value is
; 4602 : never set for an anchored regular expression, but the anchoring may be forced
; 4603 : at run time, so we have to test for anchoring. The first char may be unset for
; 4604 : an unanchored pattern, of course. If there's no first char and the pattern was
; 4605 : studied, there may be a bitmap of possible first characters. */
; 4606 : 
; 4607 : if (!anchored)

	cmp	DWORD PTR _anchored$[esp+296], 0
	jne	SHORT $LN231@pcre_exec

; 4608 :   {
; 4609 :   if ((re->flags & PCRE_FIRSTSET) != 0)

	test	BYTE PTR [edi+12], 2
	je	SHORT $LN67@pcre_exec

; 4610 :     {
; 4611 :     first_byte = re->first_byte & 255;

	movzx	eax, WORD PTR [edi+20]
	mov	ecx, eax
	and	ecx, 255				; 000000ffH

; 4612 :     if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)

	shr	eax, 8
	and	eax, 1
	mov	DWORD PTR _first_byte$[esp+296], ecx
	mov	DWORD PTR _first_byte_caseless$[esp+296], eax
	je	SHORT $LN231@pcre_exec

; 4613 :       first_byte = md->lcc[first_byte];

	mov	eax, DWORD PTR _match_block$[esp+332]
	movzx	ecx, BYTE PTR [eax+ecx]
	mov	DWORD PTR _first_byte$[esp+296], ecx

; 4614 :     }
; 4615 :   else

	jmp	SHORT $LN231@pcre_exec
$LN67@pcre_exec:

; 4616 :     if (!startline && study != NULL &&
; 4617 :       (study->options & PCRE_STUDY_MAPPED) != 0)

	cmp	DWORD PTR _startline$[esp+296], 0
	jne	SHORT $LN231@pcre_exec
	mov	eax, DWORD PTR _study$[esp+296]
	test	eax, eax
	je	SHORT $LN231@pcre_exec
	test	BYTE PTR [eax+4], 1
	je	SHORT $LN231@pcre_exec

; 4618 :         start_bits = study->start_bits;

	add	eax, 8
	mov	DWORD PTR _start_bits$[esp+296], eax
$LN231@pcre_exec:

; 4619 :   }
; 4620 : 
; 4621 : /* For anchored or unanchored matches, there may be a "last known required
; 4622 : character" set. */
; 4623 : 
; 4624 : if ((re->flags & PCRE_REQCHSET) != 0)

	test	BYTE PTR [edi+12], 4
	je	SHORT $LL216@pcre_exec

; 4625 :   {
; 4626 :   req_byte = re->req_byte & 255;

	movzx	eax, WORD PTR [edi+22]

; 4627 :   req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
; 4628 :   req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */

	mov	edx, DWORD PTR _tables$[esp+296]
	mov	ecx, eax
	and	ecx, 255				; 000000ffH
	shr	eax, 8
	and	eax, 1
	mov	DWORD PTR _req_byte_caseless$[esp+296], eax
	movzx	eax, BYTE PTR [edx+ecx+256]
	mov	DWORD PTR _req_byte$[esp+296], ecx
	mov	DWORD PTR _req_byte2$[esp+296], eax
	npad	2
$LL216@pcre_exec:

; 4853 : 
; 4854 :   }   /* End of for(;;) "bumpalong" loop */

	mov	edi, DWORD PTR _match_block$[esp+308]
	test	edi, edi
	mov	esi, DWORD PTR _end_subject$[esp+296]
	mov	DWORD PTR _save_end_subject$6293[esp+296], esi
	je	SHORT $LN232@pcre_exec
	mov	ecx, DWORD PTR _resetcount$[esp+296]
	lea	ecx, DWORD PTR [edi+ecx*4]
	cmp	edi, ecx
	jae	SHORT $LN232@pcre_exec
	sub	ecx, edi
	sub	ecx, 1
	shr	ecx, 2
	add	ecx, 1
	or	eax, -1
	rep stosd
	mov	ebx, DWORD PTR _match_block$[esp+384]
$LN232@pcre_exec:
	cmp	DWORD PTR _firstline$[esp+296], 0
	mov	ecx, DWORD PTR _match_block$[esp+324]
	je	SHORT $LN236@pcre_exec
	cmp	ebp, ebx
	mov	esi, ebp
	jae	SHORT $LN233@pcre_exec
$LL56@pcre_exec:

; 4629 :   }
; 4630 : 
; 4631 : 
; 4632 : /* ==========================================================================*/
; 4633 : 
; 4634 : /* Loop for handling unanchored repeated matching attempts; for anchored regexs
; 4635 : the loop runs just once. */
; 4636 : 
; 4637 : for(;;)
; 4638 :   {
; 4639 :   USPTR save_end_subject = end_subject;
; 4640 :   USPTR new_start_match;
; 4641 : 
; 4642 :   /* Reset the maximum number of extractions we might see. */
; 4643 : 
; 4644 :   if (md->offset_vector != NULL)
; 4645 :     {
; 4646 :     register int *iptr = md->offset_vector;
; 4647 :     register int *iend = iptr + resetcount;
; 4648 :     while (iptr < iend) *iptr++ = -1;
; 4649 :     }
; 4650 : 
; 4651 :   /* Advance to a unique first char if possible. If firstline is TRUE, the
; 4652 :   start of the match is constrained to the first line of a multiline string.
; 4653 :   That is, the match must be before or at the first newline. Implement this by
; 4654 :   temporarily adjusting end_subject so that we stop scanning at a newline. If
; 4655 :   the match fails at the newline, later code breaks this loop. */
; 4656 : 
; 4657 :   if (firstline)
; 4658 :     {
; 4659 :     USPTR t = start_match;
; 4660 :     while (t < md->end_subject && !IS_NEWLINE(t)) t++;

	cmp	DWORD PTR _match_block$[esp+320], 0
	je	SHORT $LN124@pcre_exec
	mov	edx, DWORD PTR _utf8$[esp+296]
	mov	ecx, DWORD PTR _match_block$[esp+320]
	push	edx
	lea	eax, DWORD PTR _match_block$[esp+328]
	push	eax
	push	ebx
	push	ecx
	push	esi
	call	__pcre_is_newline
	mov	ecx, DWORD PTR _match_block$[esp+344]
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	SHORT $LN233@pcre_exec
	mov	ebx, DWORD PTR _match_block$[esp+384]
	jmp	SHORT $LN120@pcre_exec
$LN124@pcre_exec:
	mov	edx, ebx
	sub	edx, ecx
	cmp	esi, edx
	ja	SHORT $LN120@pcre_exec
	mov	al, BYTE PTR [esi]
	cmp	al, BYTE PTR _match_block$[esp+328]
	jne	SHORT $LN120@pcre_exec
	cmp	ecx, 1
	je	SHORT $LN233@pcre_exec
	mov	dl, BYTE PTR [esi+1]
	cmp	dl, BYTE PTR _match_block$[esp+329]
	je	SHORT $LN233@pcre_exec
$LN120@pcre_exec:
	add	esi, 1
	cmp	esi, ebx
	jb	SHORT $LL56@pcre_exec
$LN233@pcre_exec:

; 4661 :     end_subject = t;

	mov	DWORD PTR _end_subject$[esp+296], esi
$LN236@pcre_exec:

; 4662 :     }
; 4663 : 
; 4664 :   /* Now test for a unique first byte */
; 4665 : 
; 4666 :   if (first_byte >= 0)

	mov	ebx, DWORD PTR _first_byte$[esp+296]
	test	ebx, ebx
	jl	SHORT $LN54@pcre_exec

; 4667 :     {
; 4668 :     if (first_byte_caseless)

	cmp	DWORD PTR _first_byte_caseless$[esp+296], 0
	je	SHORT $LN148@pcre_exec

; 4669 :       while (start_match < end_subject &&
; 4670 :              md->lcc[*start_match] != first_byte)

	cmp	ebp, esi
	jae	$LN241@pcre_exec
	npad	6
$LL52@pcre_exec:
	movzx	eax, BYTE PTR [ebp]
	mov	ecx, DWORD PTR _match_block$[esp+332]
	movzx	edx, BYTE PTR [eax+ecx]
	cmp	edx, ebx
	je	$LN241@pcre_exec

; 4671 :         { NEXTCHAR(start_match); }

	add	ebp, 1
	cmp	ebp, esi
	jb	SHORT $LL52@pcre_exec

; 4672 :     else

	jmp	$LN241@pcre_exec
$LN148@pcre_exec:

; 4673 :       while (start_match < end_subject && *start_match != first_byte)

	cmp	ebp, esi
	jae	$LN241@pcre_exec
	npad	8
$LL49@pcre_exec:
	movzx	eax, BYTE PTR [ebp]
	cmp	eax, ebx
	je	$LN241@pcre_exec

; 4674 :         { NEXTCHAR(start_match); }

	add	ebp, 1
	cmp	ebp, esi
	jb	SHORT $LL49@pcre_exec

; 4675 :     }
; 4676 : 
; 4677 :   /* Or to just after a linebreak for a multiline match if possible */
; 4678 : 
; 4679 :   else if (startline)

	jmp	$LN241@pcre_exec
$LN54@pcre_exec:
	cmp	DWORD PTR _startline$[esp+296], 0
	je	$LN46@pcre_exec

; 4680 :     {
; 4681 :     if (start_match > md->start_subject + start_offset)

	mov	edx, DWORD PTR _start_offset$[esp+292]
	mov	eax, DWORD PTR _match_block$[esp+380]
	add	edx, eax
	cmp	ebp, edx
	jbe	$LN241@pcre_exec

; 4682 :       {
; 4683 :       while (start_match <= end_subject && !WAS_NEWLINE(start_match))

	cmp	ebp, esi
	ja	$LN239@pcre_exec
	jmp	SHORT $LN44@pcre_exec
	npad	8
$LL243@pcre_exec:
	mov	eax, DWORD PTR _match_block$[esp+380]
$LN44@pcre_exec:
	cmp	DWORD PTR _match_block$[esp+320], 0
	je	SHORT $LN131@pcre_exec
	cmp	ebp, eax
	jbe	SHORT $LN237@pcre_exec
	mov	eax, DWORD PTR _utf8$[esp+296]
	mov	edx, DWORD PTR _match_block$[esp+380]
	push	eax
	mov	eax, DWORD PTR _match_block$[esp+324]
	lea	ecx, DWORD PTR _match_block$[esp+328]
	push	ecx
	push	edx
	push	eax
	push	ebp
	call	__pcre_was_newline
	mov	esi, DWORD PTR _end_subject$[esp+316]
	mov	ebx, DWORD PTR _first_byte$[esp+316]
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	SHORT $LN239@pcre_exec
	mov	ecx, DWORD PTR _match_block$[esp+324]
	jmp	SHORT $LN237@pcre_exec
$LN131@pcre_exec:
	lea	edx, DWORD PTR [ecx+eax]
	cmp	ebp, edx
	jb	SHORT $LN237@pcre_exec
	mov	dl, BYTE PTR _match_block$[esp+328]
	mov	eax, ebp
	sub	eax, ecx
	cmp	BYTE PTR [eax], dl
	jne	SHORT $LN237@pcre_exec
	cmp	ecx, 1
	je	SHORT $LN239@pcre_exec
	mov	dl, BYTE PTR _match_block$[esp+329]
	cmp	BYTE PTR [eax+1], dl
	je	SHORT $LN239@pcre_exec
$LN237@pcre_exec:

; 4684 :         { NEXTCHAR(start_match); }

	add	ebp, 1
	cmp	ebp, esi
	jbe	SHORT $LL243@pcre_exec
$LN239@pcre_exec:

; 4685 : 
; 4686 :       /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
; 4687 :       and we are now at a LF, advance the match position by one more character.
; 4688 :       */
; 4689 : 
; 4690 :       if (start_match[-1] == '\r' &&
; 4691 :            (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
; 4692 :            start_match < end_subject &&
; 4693 :            *start_match == '\n')

	cmp	BYTE PTR [ebp-1], 13			; 0000000dH
	jne	SHORT $LN241@pcre_exec
	mov	eax, DWORD PTR _match_block$[esp+320]
	cmp	eax, 1
	je	SHORT $LN41@pcre_exec
	cmp	eax, 2
	jne	SHORT $LN241@pcre_exec
$LN41@pcre_exec:
	cmp	ebp, esi
	jae	SHORT $LN241@pcre_exec
	cmp	BYTE PTR [ebp], 10			; 0000000aH
	jne	SHORT $LN241@pcre_exec

; 4694 :         start_match++;

	add	ebp, 1

; 4695 :       }

	jmp	SHORT $LN241@pcre_exec
$LN46@pcre_exec:

; 4696 :     }
; 4697 : 
; 4698 :   /* Or to a non-unique first char after study */
; 4699 : 
; 4700 :   else if (start_bits != NULL)

	mov	edi, DWORD PTR _start_bits$[esp+296]
	test	edi, edi
	je	SHORT $LN241@pcre_exec

; 4701 :     {
; 4702 :     while (start_match < end_subject)

	cmp	ebp, esi
	jae	SHORT $LN241@pcre_exec
	npad	2
$LL38@pcre_exec:

; 4703 :       {
; 4704 :       register unsigned int c = *start_match;

	movzx	eax, BYTE PTR [ebp]

; 4705 :       if ((start_bits[c/8] & (1 << (c&7))) == 0)

	mov	ecx, eax
	and	ecx, 7
	mov	edx, 1
	shl	edx, cl
	shr	eax, 3
	mov	al, BYTE PTR [eax+edi]
	test	dl, al
	jne	SHORT $LN241@pcre_exec

; 4706 :         { NEXTCHAR(start_match); }

	add	ebp, 1
	cmp	ebp, esi
	jb	SHORT $LL38@pcre_exec
$LN241@pcre_exec:

; 4707 :       else break;
; 4708 :       }
; 4709 :     }
; 4710 : 
; 4711 :   /* Restore fudged end_subject */
; 4712 : 
; 4713 :   end_subject = save_end_subject;
; 4714 : 
; 4715 : #ifdef DEBUG  /* Sigh. Some compilers never learn. */
; 4716 :   printf(">>>> Match against: ");
; 4717 :   pchars(start_match, end_subject - start_match, TRUE, md);
; 4718 :   printf("\n");
; 4719 : #endif
; 4720 : 
; 4721 :   /* If req_byte is set, we know that that character must appear in the subject
; 4722 :   for the match to succeed. If the first character is set, req_byte must be
; 4723 :   later in the subject; otherwise the test starts at the match point. This
; 4724 :   optimization can save a huge amount of backtracking in patterns with nested
; 4725 :   unlimited repeats that aren't going to match. Writing separate code for
; 4726 :   cased/caseless versions makes it go faster, as does using an autoincrement
; 4727 :   and backing off on a match.
; 4728 : 
; 4729 :   HOWEVER: when the subject string is very, very long, searching to its end can
; 4730 :   take a long time, and give bad performance on quite ordinary patterns. This
; 4731 :   showed up when somebody was matching something like /^\d+C/ on a 32-megabyte
; 4732 :   string... so we don't do this when the string is sufficiently long.
; 4733 : 
; 4734 :   ALSO: this processing is disabled when partial matching is requested.
; 4735 :   */
; 4736 : 
; 4737 :   if (req_byte >= 0 &&
; 4738 :       end_subject - start_match < REQ_BYTE_MAX &&
; 4739 :       !md->partial)

	mov	esi, DWORD PTR _req_byte$[esp+296]
	test	esi, esi
	mov	edx, DWORD PTR _save_end_subject$6293[esp+296]
	mov	DWORD PTR _end_subject$[esp+296], edx
	jl	$LN33@pcre_exec
	mov	ecx, edx
	sub	ecx, ebp
	cmp	ecx, 1000				; 000003e8H
	jge	$LN33@pcre_exec
	cmp	DWORD PTR _match_block$[esp+364], 0
	jne	$LN33@pcre_exec

; 4740 :     {
; 4741 :     register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);

	xor	eax, eax
	test	ebx, ebx
	setge	al
	add	eax, ebp

; 4742 : 
; 4743 :     /* We don't need to repeat the search if we haven't yet reached the
; 4744 :     place we found it at last time. */
; 4745 : 
; 4746 :     if (p > req_byte_ptr)

	cmp	eax, DWORD PTR _req_byte_ptr$[esp+296]
	jbe	$LN33@pcre_exec

; 4747 :       {
; 4748 :       if (req_byte_caseless)

	cmp	DWORD PTR _req_byte_caseless$[esp+296], 0
	je	SHORT $LN152@pcre_exec

; 4749 :         {
; 4750 :         while (p < end_subject)

	cmp	eax, edx
	jae	SHORT $LN244@pcre_exec
	mov	edi, DWORD PTR _req_byte2$[esp+296]
	npad	2
$LL31@pcre_exec:

; 4751 :           {
; 4752 :           register int pp = *p++;

	movzx	ecx, BYTE PTR [eax]
	add	eax, 1

; 4753 :           if (pp == req_byte || pp == req_byte2) { p--; break; }

	cmp	ecx, esi
	je	SHORT $LN154@pcre_exec
	cmp	ecx, edi
	je	SHORT $LN154@pcre_exec

; 4749 :         {
; 4750 :         while (p < end_subject)

	cmp	eax, edx
	jb	SHORT $LL31@pcre_exec
$LN244@pcre_exec:

; 4768 :         {
; 4769 :         rc = MATCH_NOMATCH;

	xor	esi, esi
$LN225@pcre_exec:

; 4906 :     }
; 4907 : 
; 4908 :   DPRINTF((">>>> returning %d\n", rc));
; 4909 :   return rc;
; 4910 :   }
; 4911 : 
; 4912 : /* Control gets here if there has been an error, or if the overall match
; 4913 : attempt has failed at all permitted starting positions. */
; 4914 : 
; 4915 : if (using_temporary_offsets)

	cmp	DWORD PTR _using_temporary_offsets$[esp+296], 0
	je	SHORT $LN5@pcre_exec

; 4916 :   {
; 4917 :   DPRINTF(("Freeing temporary memory\n"));
; 4918 :   (pcre_free)(md->offset_vector);

	mov	ecx, DWORD PTR _match_block$[esp+308]
	push	ecx
	call	DWORD PTR _pcre_free
	add	esp, 4
$LN5@pcre_exec:

; 4919 :   }
; 4920 : 
; 4921 : if (rc != MATCH_NOMATCH)

	test	esi, esi
	je	$LN4@pcre_exec
	pop	edi

; 4922 :   {
; 4923 :   DPRINTF((">>>> error: returning %d\n", rc));
; 4924 :   return rc;

	mov	eax, esi
	pop	esi
	pop	ebp
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN152@pcre_exec:

; 4754 :           }
; 4755 :         }
; 4756 :       else
; 4757 :         {
; 4758 :         while (p < end_subject)

	cmp	eax, edx
	jae	SHORT $LN244@pcre_exec
$LL26@pcre_exec:

; 4759 :           {
; 4760 :           if (*p++ == req_byte) { p--; break; }

	movzx	ecx, BYTE PTR [eax]
	add	eax, 1
	cmp	ecx, esi
	je	SHORT $LN154@pcre_exec

; 4754 :           }
; 4755 :         }
; 4756 :       else
; 4757 :         {
; 4758 :         while (p < end_subject)

	cmp	eax, edx
	jb	SHORT $LL26@pcre_exec
	jmp	SHORT $LN244@pcre_exec
$LN154@pcre_exec:

; 4759 :           {
; 4760 :           if (*p++ == req_byte) { p--; break; }

	sub	eax, 1

; 4761 :           }
; 4762 :         }
; 4763 : 
; 4764 :       /* If we can't find the required character, break the matching loop,
; 4765 :       forcing a match failure. */
; 4766 : 
; 4767 :       if (p >= end_subject)

	cmp	eax, edx
	jae	SHORT $LN244@pcre_exec

; 4770 :         break;
; 4771 :         }
; 4772 : 
; 4773 :       /* If we have found the required character, save the point where we
; 4774 :       found it, so that we don't search again next time round the loop if
; 4775 :       the start hasn't passed this character yet. */
; 4776 : 
; 4777 :       req_byte_ptr = p;

	mov	DWORD PTR _req_byte_ptr$[esp+296], eax
$LN33@pcre_exec:

; 4778 :       }
; 4779 :     }
; 4780 : 
; 4781 :   /* OK, we can now run the match. */
; 4782 : 
; 4783 :   md->start_match_ptr = start_match;
; 4784 :   md->match_call_count = 0;
; 4785 :   rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);

	mov	edx, DWORD PTR _ims$[esp+296]
	mov	ecx, DWORD PTR _match_block$[esp+376]
	push	0
	push	0
	push	0
	push	edx
	lea	eax, DWORD PTR _match_block$[esp+312]
	push	eax
	push	2
	push	ebp
	push	ecx
	push	ebp
	mov	DWORD PTR _match_block$[esp+424], ebp
	mov	DWORD PTR _match_block$[esp+332], 0
	call	_match
	mov	esi, eax
	add	esp, 36					; 00000024H

; 4786 : 
; 4787 :   switch(rc)

	test	esi, esi
	jg	$ENDLOOP$6357
	je	SHORT $LN20@pcre_exec
	lea	eax, DWORD PTR [esi+999]
	cmp	eax, 3
	ja	$ENDLOOP$6357
	jmp	DWORD PTR $LN254@pcre_exec[eax*4]
$LN19@pcre_exec:

; 4796 : #ifdef SUPPORT_UTF8
; 4797 :     if (utf8)
; 4798 :       while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
; 4799 :         new_start_match++;
; 4800 : #endif
; 4801 :     break;
; 4802 : 
; 4803 :     /* SKIP passes back the next starting point explicitly. */
; 4804 : 
; 4805 :     case MATCH_SKIP:
; 4806 :     new_start_match = md->start_match_ptr;

	mov	edi, DWORD PTR _match_block$[esp+388]

; 4807 :     break;

	jmp	SHORT $LN21@pcre_exec
$LN20@pcre_exec:

; 4788 :     {
; 4789 :     /* NOMATCH and PRUNE advance by one character. THEN at this level acts
; 4790 :     exactly like PRUNE. */
; 4791 : 
; 4792 :     case MATCH_NOMATCH:
; 4793 :     case MATCH_PRUNE:
; 4794 :     case MATCH_THEN:
; 4795 :     new_start_match = start_match + 1;

	lea	edi, DWORD PTR [ebp+1]
$LN21@pcre_exec:

; 4808 : 
; 4809 :     /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
; 4810 : 
; 4811 :     case MATCH_COMMIT:
; 4812 :     rc = MATCH_NOMATCH;
; 4813 :     goto ENDLOOP;
; 4814 : 
; 4815 :     /* Any other return is some kind of error. */
; 4816 : 
; 4817 :     default:
; 4818 :     goto ENDLOOP;
; 4819 :     }
; 4820 : 
; 4821 :   /* Control reaches here for the various types of "no match at this point"
; 4822 :   result. Reset the code to MATCH_NOMATCH for subsequent checking. */
; 4823 : 
; 4824 :   rc = MATCH_NOMATCH;
; 4825 : 
; 4826 :   /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
; 4827 :   newline in the subject (though it may continue over the newline). Therefore,
; 4828 :   if we have just failed to match, starting at a newline, do not continue. */
; 4829 : 
; 4830 :   if (firstline && IS_NEWLINE(start_match)) break;

	mov	ebx, DWORD PTR _match_block$[esp+384]
	xor	esi, esi
	cmp	DWORD PTR _firstline$[esp+296], esi
	je	SHORT $LN224@pcre_exec
	cmp	DWORD PTR _match_block$[esp+320], esi
	je	SHORT $LN139@pcre_exec
	cmp	ebp, ebx
	jae	SHORT $LN224@pcre_exec
	mov	edx, DWORD PTR _utf8$[esp+296]
	mov	ecx, DWORD PTR _match_block$[esp+320]
	push	edx
	lea	eax, DWORD PTR _match_block$[esp+328]
	push	eax
	push	ebx
	push	ecx
	push	ebp
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	jne	$LN225@pcre_exec
	mov	ebx, DWORD PTR _match_block$[esp+384]
	jmp	SHORT $LN224@pcre_exec
$LN139@pcre_exec:
	mov	eax, DWORD PTR _match_block$[esp+324]
	mov	edx, ebx
	sub	edx, eax
	cmp	ebp, edx
	ja	SHORT $LN224@pcre_exec
	mov	cl, BYTE PTR _match_block$[esp+328]
	cmp	BYTE PTR [ebp], cl
	jne	SHORT $LN224@pcre_exec
	cmp	eax, 1
	je	$LN225@pcre_exec
	mov	dl, BYTE PTR _match_block$[esp+329]
	cmp	BYTE PTR [ebp+1], dl
	je	$LN225@pcre_exec
$LN224@pcre_exec:

; 4831 : 
; 4832 :   /* Advance to new matching position */
; 4833 : 
; 4834 :   start_match = new_start_match;
; 4835 : 
; 4836 :   /* Break the loop if the pattern is anchored or if we have passed the end of
; 4837 :   the subject. */
; 4838 : 
; 4839 :   if (anchored || start_match > end_subject) break;

	cmp	DWORD PTR _anchored$[esp+296], 0
	mov	ebp, edi
	jne	$LN225@pcre_exec
	cmp	edi, DWORD PTR _save_end_subject$6293[esp+296]
	ja	$LN225@pcre_exec

; 4840 : 
; 4841 :   /* If we have just passed a CR and we are now at a LF, and the pattern does
; 4842 :   not contain any explicit matches for \r or \n, and the newline option is CRLF
; 4843 :   or ANY or ANYCRLF, advance the match position by one more character. */
; 4844 : 
; 4845 :   if (start_match[-1] == '\r' &&
; 4846 :       start_match < end_subject &&
; 4847 :       *start_match == '\n' &&
; 4848 :       (re->flags & PCRE_HASCRORLF) == 0 &&
; 4849 :         (md->nltype == NLTYPE_ANY ||
; 4850 :          md->nltype == NLTYPE_ANYCRLF ||
; 4851 :          md->nllen == 2))

	cmp	BYTE PTR [edi-1], 13			; 0000000dH
	jne	$LL216@pcre_exec
	cmp	edi, DWORD PTR _save_end_subject$6293[esp+296]
	jae	$LL216@pcre_exec
	cmp	BYTE PTR [edi], 10			; 0000000aH
	jne	$LL216@pcre_exec
	mov	eax, DWORD PTR _re$[esp+296]
	test	BYTE PTR [eax+12], 32			; 00000020H
	jne	$LL216@pcre_exec
	mov	eax, DWORD PTR _match_block$[esp+320]
	cmp	eax, 1
	je	SHORT $LN12@pcre_exec
	cmp	eax, 2
	je	SHORT $LN12@pcre_exec
	cmp	DWORD PTR _match_block$[esp+324], 2
	jne	$LL216@pcre_exec
$LN12@pcre_exec:

; 4852 :     start_match++;

	lea	ebp, DWORD PTR [edi+1]

; 4853 : 
; 4854 :   }   /* End of for(;;) "bumpalong" loop */

	jmp	$LL216@pcre_exec
$ENDLOOP$6357:

; 4855 : 
; 4856 : /* ==========================================================================*/
; 4857 : 
; 4858 : /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
; 4859 : conditions is true:
; 4860 : 
; 4861 : (1) The pattern is anchored or the match was failed by (*COMMIT);
; 4862 : 
; 4863 : (2) We are past the end of the subject;
; 4864 : 
; 4865 : (3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
; 4866 :     this option requests that a match occur at or before the first newline in
; 4867 :     the subject.
; 4868 : 
; 4869 : When we have a match and the offset vector is big enough to deal with any
; 4870 : backreferences, captured substring offsets will already be set up. In the case
; 4871 : where we had to get some local store to hold offsets for backreference
; 4872 : processing, copy those that we can. In this case there need not be overflow if
; 4873 : certain parts of the pattern were not used, even though there are more
; 4874 : capturing parentheses than vector slots. */
; 4875 : 
; 4876 : ENDLOOP:
; 4877 : 
; 4878 : if (rc == MATCH_MATCH)

	cmp	esi, 1
	jne	$LN225@pcre_exec

; 4879 :   {
; 4880 :   if (using_temporary_offsets)

	cmp	DWORD PTR _using_temporary_offsets$[esp+296], 0

; 4881 :     {
; 4882 :     if (offsetcount >= 4)

	mov	esi, DWORD PTR _offsetcount$[esp+292]
	je	SHORT $LN10@pcre_exec
	cmp	esi, 4
	mov	edi, DWORD PTR _match_block$[esp+308]
	jl	SHORT $LN227@pcre_exec

; 4883 :       {
; 4884 :       memcpy(offsets + 2, md->offset_vector + 2,
; 4885 :         (offsetcount - 2) * sizeof(int));

	mov	eax, DWORD PTR _offsets$[esp+292]
	lea	ecx, DWORD PTR [esi*4-8]
	push	ecx
	lea	edx, DWORD PTR [edi+8]
	push	edx
	add	eax, 8
	push	eax
	call	_memcpy
	add	esp, 12					; 0000000cH
$LN227@pcre_exec:

; 4886 :       DPRINTF(("Copied offsets from temporary memory\n"));
; 4887 :       }
; 4888 :     if (md->end_offset_top > offsetcount) md->offset_overflow = TRUE;

	cmp	DWORD PTR _match_block$[esp+396], esi
	jle	SHORT $LN8@pcre_exec
	mov	DWORD PTR _match_block$[esp+340], 1
$LN8@pcre_exec:

; 4889 :     DPRINTF(("Freeing temporary memory\n"));
; 4890 :     (pcre_free)(md->offset_vector);

	push	edi
	call	DWORD PTR _pcre_free
	add	esp, 4
$LN10@pcre_exec:

; 4891 :     }
; 4892 : 
; 4893 :   /* Set the return code to the number of captured strings, or 0 if there are
; 4894 :   too many to fit into the vector. */
; 4895 : 
; 4896 :   rc = md->offset_overflow? 0 : md->end_offset_top/2;

	cmp	DWORD PTR _match_block$[esp+340], 0
	je	SHORT $LN141@pcre_exec
	xor	eax, eax
	jmp	SHORT $LN142@pcre_exec
$LN141@pcre_exec:
	mov	eax, DWORD PTR _match_block$[esp+396]
	cdq
	sub	eax, edx
	sar	eax, 1
$LN142@pcre_exec:

; 4897 : 
; 4898 :   /* If there is space, set up the whole thing as substring 0. The value of
; 4899 :   md->start_match_ptr might be modified if \K was encountered on the success
; 4900 :   matching path. */
; 4901 : 
; 4902 :   if (offsetcount < 2) rc = 0; else

	cmp	esi, 2
	jge	SHORT $LN7@pcre_exec
	pop	edi
	pop	esi
	pop	ebp
	xor	eax, eax
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN7@pcre_exec:

; 4903 :     {
; 4904 :     offsets[0] = md->start_match_ptr - md->start_subject;

	mov	ecx, DWORD PTR _match_block$[esp+380]
	mov	esi, DWORD PTR _match_block$[esp+388]
	mov	edx, DWORD PTR _offsets$[esp+292]
	sub	esi, ecx
	mov	DWORD PTR [edx], esi

; 4905 :     offsets[1] = md->end_match_ptr - md->start_subject;

	mov	esi, DWORD PTR _match_block$[esp+392]
	sub	esi, ecx
	pop	edi
	mov	DWORD PTR [edx+4], esi
	pop	esi
	pop	ebp
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN4@pcre_exec:

; 4925 :   }
; 4926 : else if (md->partial && md->hitend)

	cmp	DWORD PTR _match_block$[esp+364], 0
	je	SHORT $LN2@pcre_exec
	cmp	DWORD PTR _match_block$[esp+368], 0
	je	SHORT $LN2@pcre_exec
	pop	edi
	pop	esi
	pop	ebp

; 4927 :   {
; 4928 :   DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
; 4929 :   return PCRE_ERROR_PARTIAL;

	mov	eax, -12				; fffffff4H
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN2@pcre_exec:
	pop	edi
	pop	esi
	pop	ebp

; 4930 :   }
; 4931 : else
; 4932 :   {
; 4933 :   DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
; 4934 :   return PCRE_ERROR_NOMATCH;

	or	eax, -1
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
$LN111@pcre_exec:
	pop	edi
	pop	esi
	pop	ebp

; 4385 : if (re == NULL || subject == NULL ||
; 4386 :    (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;

	mov	eax, -2					; fffffffeH
	pop	ebx

; 4935 :   }
; 4936 : }

	add	esp, 280				; 00000118H
	ret	0
	npad	2
$LN254@pcre_exec:
	DD	$LN244@pcre_exec
	DD	$LN20@pcre_exec
	DD	$LN19@pcre_exec
	DD	$LN20@pcre_exec
_pcre_exec ENDP
_TEXT	ENDS
END
