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

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

INCLUDELIB LIBCMTD
INCLUDELIB OLDNAMES

_DATA	SEGMENT
_verbs	DD	06H
	DD	06dH
	DD	06H
	DD	06bH
	DD	01H
	DD	06cH
	DD	04H
	DD	06cH
	DD	05H
	DD	068H
	DD	04H
	DD	069H
	DD	04H
	DD	06aH
_verbcount DD	07H
_DATA	ENDS
CONST	SEGMENT
_escapes DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	03aH
	DW	03bH
	DW	03cH
	DW	03dH
	DW	03eH
	DW	03fH
	DW	040H
	DW	0ffffH
	DW	0fffcH
	DW	0fff3H
	DW	0fffaH
	DW	0ffe8H
	DW	00H
	DW	0fffeH
	DW	0ffefH
	DW	00H
	DW	00H
	DW	0fffdH
	DW	00H
	DW	00H
	DW	00H
	DW	00H
	DW	0fff2H
	DW	0ffe7H
	DW	0fff0H
	DW	0fff8H
	DW	00H
	DW	00H
	DW	0ffedH
	DW	0fff6H
	DW	0ffebH
	DW	00H
	DW	0ffeaH
	DW	05bH
	DW	05cH
	DW	05dH
	DW	05eH
	DW	05fH
	DW	060H
	DW	07H
	DW	0fffbH
	DW	00H
	DW	0fff9H
	DW	01bH
	DW	0cH
	DW	00H
	DW	0ffeeH
	DW	00H
	DW	00H
	DW	0ffe6H
	DW	00H
	DW	00H
	DW	0aH
	DW	00H
	DW	0fff1H
	DW	00H
	DW	0dH
	DW	0fff7H
	DW	09H
	DW	00H
	DW	0ffecH
	DW	0fff5H
	DW	00H
	DW	00H
	DW	0ffe9H
	ORG $+2
_verbnames DB	'ACCEPT', 00H, 'COMMIT', 00H, 'F', 00H, 'FAIL', 00H, 'PRU'
	DB	'NE', 00H, 'SKIP', 00H, 'THEN', 00H
	ORG $+3
_posix_names DB	'alpha', 00H, 'lower', 00H, 'upper', 00H, 'alnum', 00H, 'a'
	DB	'scii', 00H, 'blank', 00H, 'cntrl', 00H, 'digit', 00H, 'graph', 00H
	DB	'print', 00H, 'punct', 00H, 'space', 00H, 'word', 00H, 'xdigit'
	DB	00H
_posix_name_lengths DB 05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	05H
	DB	04H
	DB	06H
	DB	00H
	ORG $+5
_posix_class_maps DD 0a0H
	DD	040H
	DD	0fffffffeH
	DD	080H
	DD	0ffffffffH
	DD	00H
	DD	060H
	DD	0ffffffffH
	DD	00H
	DD	0a0H
	DD	0ffffffffH
	DD	02H
	DD	0e0H
	DD	0120H
	DD	00H
	DD	00H
	DD	0ffffffffH
	DD	01H
	DD	0120H
	DD	0ffffffffH
	DD	00H
	DD	040H
	DD	0ffffffffH
	DD	00H
	DD	0c0H
	DD	0ffffffffH
	DD	00H
	DD	0e0H
	DD	0ffffffffH
	DD	00H
	DD	0100H
	DD	0ffffffffH
	DD	00H
	DD	00H
	DD	0ffffffffH
	DD	00H
	DD	0a0H
	DD	0ffffffffH
	DD	00H
	DD	020H
	DD	0ffffffffH
	DD	00H
_error_texts DB	'no error', 00H, '\ at end of pattern', 00H, '\c at end o'
	DB	'f pattern', 00H, 'unrecognized character follows \', 00H, 'nu'
	DB	'mbers out of order in {} quantifier', 00H, 'number too big in'
	DB	' {} quantifier', 00H, 'missing terminating ] for character cl'
	DB	'ass', 00H, 'invalid escape sequence in character class', 00H, 'r'
	DB	'ange out of order in character class', 00H, 'nothing to repea'
	DB	't', 00H, 'operand of unlimited repeat could match the empty s'
	DB	'tring', 00H, 'internal error: unexpected repeat', 00H, 'unrec'
	DB	'ognized character after (? or (?-', 00H, 'POSIX named classes'
	DB	' are supported only within a class', 00H, 'missing )', 00H, 'r'
	DB	'eference to non-existent subpattern', 00H, 'erroffset passed '
	DB	'as NULL', 00H, 'unknown option bit(s) set', 00H, 'missing ) a'
	DB	'fter comment', 00H, 'parentheses nested too deeply', 00H, 're'
	DB	'gular expression is too large', 00H, 'failed to get memory', 00H
	DB	'unmatched parentheses', 00H, 'internal error: code overflow', 00H
	DB	'unrecognized character after (?<', 00H, 'lookbehind assertion'
	DB	' is not fixed length', 00H, 'malformed number or name after ('
	DB	'?(', 00H, 'conditional group contains more than two branches', 00H
	DB	'assertion expected after (?(', 00H, '(?R or (?[+-]digits must'
	DB	' be followed by )', 00H, 'unknown POSIX class name', 00H, 'PO'
	DB	'SIX collating elements are not supported', 00H, 'this version'
	DB	' of PCRE is not compiled with PCRE_UTF8 support', 00H, 'spare'
	DB	' error', 00H, 'character value in \x{...} sequence is too lar'
	DB	'ge', 00H, 'invalid condition (?(0)', 00H, '\C not allowed in '
	DB	'lookbehind assertion', 00H, 'PCRE does not support \L, \l, \N'
	DB	', \U, or \u', 00H, 'number after (?C is > 255', 00H, 'closing'
	DB	' ) for (?C expected', 00H, 'recursive call could loop indefin'
	DB	'itely', 00H, 'unrecognized character after (?P', 00H, 'syntax'
	DB	' error in subpattern name (missing terminator)', 00H, 'two na'
	DB	'med subpatterns have the same name', 00H, 'invalid UTF-8 stri'
	DB	'ng', 00H, 'support for \P, \p, and \X has not been compiled', 00H
	DB	'malformed \P or \p sequence', 00H, 'unknown property name aft'
	DB	'er \P or \p', 00H, 'subpattern name is too long (maximum 32 c'
	DB	'haracters)', 00H, 'too many named subpatterns (maximum 10000)'
	DB	00H, 'repeated subpattern is too long', 00H, 'octal value is g'
	DB	'reater than \377 (not in UTF-8 mode)', 00H, 'internal error: '
	DB	'overran compiling workspace', 00H, 'internal error: previousl'
	DB	'y-checked referenced subpattern not found', 00H, 'DEFINE grou'
	DB	'p contains more than one branch', 00H, 'repeating a DEFINE gr'
	DB	'oup is not allowed', 00H, 'inconsistent NEWLINE options', 00H
	DB	'\g is not followed by a braced name or an optionally braced n'
	DB	'on-zero number', 00H, '(?+ or (?- or (?(+ or (?(- must be fol'
	DB	'lowed by a non-zero number', 00H, '(*VERB) with an argument i'
	DB	's not supported', 00H, '(*VERB) not recognized', 00H, 'number'
	DB	' is too big', 00H, 'subpattern name expected', 00H, 'digit ex'
	DB	'pected after (?+', 00H
	ORG $+4
_digitab DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	0cH
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	08H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
	DB	00H
; Function compile flags: /Ogtpy
; File d:\source code\nc lib\regex\pcre_compile.c
CONST	ENDS
;	COMDAT _find_error_text
_TEXT	SEGMENT
_find_error_text PROC					; COMDAT
; _n$ = ecx

; 454  : const char *s = error_texts;
; 455  : for (; n > 0; n--) while (*s++ != 0);

	test	ecx, ecx
	mov	eax, OFFSET _error_texts
	jle	SHORT $LN3@find_error
	npad	7
$LL2@find_error:
	mov	dl, BYTE PTR [eax]
	add	eax, 1
	test	dl, dl
	jne	SHORT $LL2@find_error
	sub	ecx, 1
	test	ecx, ecx
	jg	SHORT $LL2@find_error
$LN3@find_error:

; 456  : return s;
; 457  : }

	ret	0
_find_error_text ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _check_escape
_TEXT	SEGMENT
_i$ = -4						; size = 4
_ptrptr$ = 8						; size = 4
_errorcodeptr$ = 12					; size = 4
_bracount$ = 16						; size = 4
_isclass$ = 20						; size = 4
_check_escape PROC					; COMDAT
; _options$ = eax

; 487  : {

	push	ecx
	push	ebx
	mov	ebx, eax

; 488  : BOOL utf8 = (options & PCRE_UTF8) != 0;
; 489  : const uschar *ptr = *ptrptr + 1;

	mov	eax, DWORD PTR _ptrptr$[esp+4]
	mov	ecx, DWORD PTR [eax]

; 490  : int c, i;
; 491  : 
; 492  : GETCHARINCTEST(c, ptr);           /* Get character value, increment pointer */

	movzx	eax, BYTE PTR [ecx+1]
	push	ebp
	add	ecx, 1
	mov	ebp, ebx
	shr	ebp, 11					; 0000000bH
	and	ebp, 1

; 493  : ptr--;                            /* Set pointer back to the last byte */
; 494  : 
; 495  : /* If backslash is at the end of the pattern, it's an error. */
; 496  : 
; 497  : if (c == 0) *errorcodeptr = ERR1;

	test	eax, eax
	jne	SHORT $LN59@check_esca
	mov	edx, DWORD PTR _errorcodeptr$[esp+8]
	mov	DWORD PTR [edx], 1

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN59@check_esca:

; 498  : 
; 499  : /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
; 500  : in a table. A non-zero result is something that can be returned immediately.
; 501  : Otherwise further processing may be required. */
; 502  : 
; 503  : #ifndef EBCDIC  /* ASCII coding */
; 504  : else if (c < '0' || c > 'z') {}                           /* Not alphanumeric */

	lea	edx, DWORD PTR [eax-48]
	cmp	edx, 74					; 0000004aH
	ja	$LN83@check_esca
	push	edi

; 505  : else if ((i = escapes[c - '0']) != 0) c = i;

	movsx	edi, WORD PTR _escapes[edx*2]
	test	edi, edi
	mov	DWORD PTR _i$[esp+16], edi
	je	SHORT $LN54@check_esca

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+12]
	mov	eax, edi
	pop	edi
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN54@check_esca:

; 506  : 
; 507  : #else           /* EBCDIC coding */
; 508  : else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphanumeric */
; 509  : else if ((i = escapes[c - 0x48]) != 0)  c = i;
; 510  : #endif
; 511  : 
; 512  : /* Escapes that need further processing, or are illegal. */
; 513  : 
; 514  : else
; 515  :   {
; 516  :   const uschar *oldptr;
; 517  :   BOOL braced, negated;
; 518  : 
; 519  :   switch (c)

	cmp	edx, 72					; 00000048H
	push	esi
	ja	$LN82@check_esca
	movzx	esi, BYTE PTR $LN78@check_esca[edx]
	jmp	DWORD PTR $LN89@check_esca[esi*4]
$LN50@check_esca:

; 520  :     {
; 521  :     /* A number of Perl escapes are not handled by PCRE. We give an explicit
; 522  :     error. */
; 523  : 
; 524  :     case 'l':
; 525  :     case 'L':
; 526  :     case 'N':
; 527  :     case 'u':
; 528  :     case 'U':
; 529  :     *errorcodeptr = ERR37;

	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	pop	esi
	pop	edi
	mov	DWORD PTR [edx], 37			; 00000025H

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN49@check_esca:

; 530  :     break;
; 531  : 
; 532  :     /* \g must be followed by a number, either plain or braced. If positive, it
; 533  :     is an absolute backreference. If negative, it is a relative backreference.
; 534  :     This is a Perl 5.10 feature. Perl 5.10 also supports \g{name} as a
; 535  :     reference to a named group. This is part of Perl's movement towards a
; 536  :     unified syntax for back references. As this is synonymous with \k{name}, we
; 537  :     fudge it up by pretending it really was \k. */
; 538  : 
; 539  :     case 'g':
; 540  :     if (ptr[1] == '{')

	cmp	BYTE PTR [ecx+1], 123			; 0000007bH
	mov	bl, 4
	jne	SHORT $LN48@check_esca

; 541  :       {
; 542  :       const uschar *p;
; 543  :       for (p = ptr+2; *p != 0 && *p != '}'; p++)

	mov	al, BYTE PTR [ecx+2]
	test	al, al
	lea	edx, DWORD PTR [ecx+2]
	je	SHORT $LN43@check_esca
	npad	4
$LL47@check_esca:
	cmp	al, 125					; 0000007dH
	je	SHORT $LN69@check_esca

; 544  :         if (*p != '-' && (digitab[*p] & ctype_digit) == 0) break;

	cmp	al, 45					; 0000002dH
	je	SHORT $LN46@check_esca
	movzx	eax, al
	test	BYTE PTR _digitab[eax], bl
	je	SHORT $LN69@check_esca
$LN46@check_esca:

; 541  :       {
; 542  :       const uschar *p;
; 543  :       for (p = ptr+2; *p != 0 && *p != '}'; p++)

	mov	al, BYTE PTR [edx+1]
	add	edx, 1
	test	al, al
	jne	SHORT $LL47@check_esca
$LN43@check_esca:

; 546  :         {
; 547  :         c = -ESC_k;
; 548  :         break;
; 549  :         }
; 550  :       braced = TRUE;

	mov	esi, 1
	add	ecx, esi

; 551  :       ptr++;

	jmp	SHORT $LN42@check_esca
$LN69@check_esca:

; 545  :       if (*p != 0 && *p != '}')

	mov	dl, BYTE PTR [edx]
	test	dl, dl
	je	SHORT $LN43@check_esca
	cmp	dl, 125					; 0000007dH
	je	SHORT $LN43@check_esca

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+16]
	pop	esi
	pop	edi
	pop	ebp
	mov	eax, -26				; ffffffe6H
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN48@check_esca:

; 552  :       }
; 553  :     else braced = FALSE;

	xor	esi, esi
$LN42@check_esca:

; 554  : 
; 555  :     if (ptr[1] == '-')

	cmp	BYTE PTR [ecx+1], 45			; 0000002dH
	jne	SHORT $LN41@check_esca

; 556  :       {
; 557  :       negated = TRUE;

	mov	edx, 1
	add	ecx, edx

; 558  :       ptr++;

	jmp	SHORT $LN40@check_esca
$LN41@check_esca:

; 559  :       }
; 560  :     else negated = FALSE;

	xor	edx, edx
$LN40@check_esca:

; 561  : 
; 562  :     c = 0;
; 563  :     while ((digitab[ptr[1]] & ctype_digit) != 0)

	movzx	edi, BYTE PTR [ecx+1]
	xor	eax, eax
	test	BYTE PTR _digitab[edi], bl
	je	SHORT $LN35@check_esca
$LL39@check_esca:

; 564  :       c = c * 10 + *(++ptr) - '0';

	movzx	edi, BYTE PTR [ecx+1]
	add	ecx, 1
	lea	eax, DWORD PTR [eax+eax*4]
	lea	eax, DWORD PTR [edi+eax*2-48]
	movzx	edi, BYTE PTR [ecx+1]
	test	BYTE PTR _digitab[edi], bl
	jne	SHORT $LL39@check_esca

; 565  : 
; 566  :     if (c < 0)

	test	eax, eax

; 567  :       {
; 568  :       *errorcodeptr = ERR61;
; 569  :       break;

	jl	$LN88@check_esca

; 570  :       }
; 571  : 
; 572  :     if (c == 0 || (braced && *(++ptr) != '}'))

	je	SHORT $LN35@check_esca
	test	esi, esi
	je	SHORT $LN84@check_esca
	add	ecx, 1
	cmp	BYTE PTR [ecx], 125			; 0000007dH
	jne	SHORT $LN35@check_esca
$LN84@check_esca:

; 575  :       break;
; 576  :       }
; 577  : 
; 578  :     if (negated)

	test	edx, edx
	je	SHORT $LN34@check_esca

; 579  :       {
; 580  :       if (c > bracount)

	mov	edx, DWORD PTR _bracount$[esp+16]
	cmp	eax, edx
	jle	SHORT $LN33@check_esca

; 581  :         {
; 582  :         *errorcodeptr = ERR15;

	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	pop	esi
	pop	edi
	mov	DWORD PTR [edx], 15			; 0000000fH

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN33@check_esca:

; 583  :         break;
; 584  :         }
; 585  :       c = bracount - (c - 1);

	sub	edx, eax
	add	edx, 1
	mov	eax, edx
$LN34@check_esca:
	pop	esi

; 586  :       }
; 587  : 
; 588  :     c = -(ESC_REF + c);

	mov	edx, -27				; ffffffe5H
	sub	edx, eax
	pop	edi
	mov	eax, edx

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN35@check_esca:

; 573  :       {
; 574  :       *errorcodeptr = ERR57;

	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	pop	esi
	pop	edi
	mov	DWORD PTR [edx], 57			; 00000039H

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN32@check_esca:

; 589  :     break;
; 590  : 
; 591  :     /* The handling of escape sequences consisting of a string of digits
; 592  :     starting with one that is not zero is not straightforward. By experiment,
; 593  :     the way Perl works seems to be as follows:
; 594  : 
; 595  :     Outside a character class, the digits are read as a decimal number. If the
; 596  :     number is less than 10, or if there are that many previous extracting
; 597  :     left brackets, then it is a back reference. Otherwise, up to three octal
; 598  :     digits are read to form an escaped byte. Thus \123 is likely to be octal
; 599  :     123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
; 600  :     value is greater than 377, the least significant 8 bits are taken. Inside a
; 601  :     character class, \ followed by a digit is always an octal number. */
; 602  : 
; 603  :     case '1': case '2': case '3': case '4': case '5':
; 604  :     case '6': case '7': case '8': case '9':
; 605  : 
; 606  :     if (!isclass)

	cmp	DWORD PTR _isclass$[esp+16], 0
	jne	SHORT $LN31@check_esca

; 607  :       {
; 608  :       oldptr = ptr;
; 609  :       c -= '0';

	mov	eax, edx

; 610  :       while ((digitab[ptr[1]] & ctype_digit) != 0)

	movzx	edx, BYTE PTR [ecx+1]
	mov	bl, 4
	test	BYTE PTR _digitab[edx], bl
	mov	esi, ecx
	je	SHORT $LN29@check_esca
$LL30@check_esca:

; 611  :         c = c * 10 + *(++ptr) - '0';

	movzx	edx, BYTE PTR [ecx+1]
	add	ecx, 1
	lea	eax, DWORD PTR [eax+eax*4]
	lea	eax, DWORD PTR [edx+eax*2-48]
	movzx	edx, BYTE PTR [ecx+1]
	test	BYTE PTR _digitab[edx], bl
	jne	SHORT $LL30@check_esca
$LN29@check_esca:

; 612  :       if (c < 0)

	test	eax, eax
	jge	SHORT $LN28@check_esca
$LN88@check_esca:

; 613  :         {
; 614  :         *errorcodeptr = ERR61;

	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	pop	esi
	pop	edi
	mov	DWORD PTR [edx], 61			; 0000003dH

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN28@check_esca:

; 615  :         break;
; 616  :         }
; 617  :       if (c < 10 || c <= bracount)

	cmp	eax, 10					; 0000000aH
	jl	SHORT $LN34@check_esca
	cmp	eax, DWORD PTR _bracount$[esp+16]
	jle	$LN34@check_esca

; 618  :         {
; 619  :         c = -(ESC_REF + c);
; 620  :         break;
; 621  :         }
; 622  :       ptr = oldptr;      /* Put the pointer back and fall through */

	mov	ecx, esi
$LN31@check_esca:

; 623  :       }
; 624  : 
; 625  :     /* Handle an octal number following \. If the first digit is 8 or 9, Perl
; 626  :     generates a binary zero byte and treats the digit as a following literal.
; 627  :     Thus we have to pull back the pointer by one. */
; 628  : 
; 629  :     if ((c = *ptr) >= '8')

	movzx	eax, BYTE PTR [ecx]
	cmp	eax, 56					; 00000038H
	jl	SHORT $LN80@check_esca

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+16]
	pop	esi
	pop	edi
	sub	ecx, 1
	pop	ebp
	xor	eax, eax
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN80@check_esca:

; 630  :       {
; 631  :       ptr--;
; 632  :       c = 0;
; 633  :       break;
; 634  :       }
; 635  : 
; 636  :     /* \0 always starts an octal number, but we may drop through to here with a
; 637  :     larger first octal digit. The original code used just to take the least
; 638  :     significant 8 bits of octal numbers (I think this is what early Perls used
; 639  :     to do). Nowadays we allow for larger numbers in UTF-8 mode, but no more
; 640  :     than 3 octal digits. */
; 641  : 
; 642  :     case '0':
; 643  :     c -= '0';

	sub	eax, 48					; 00000030H
$LL23@check_esca:

; 644  :     while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')

	mov	dl, BYTE PTR [ecx+1]
	add	edi, 1
	cmp	dl, 48					; 00000030H
	jb	SHORT $LN73@check_esca
	cmp	dl, 55					; 00000037H
	ja	SHORT $LN73@check_esca

; 645  :         c = c * 8 + *(++ptr) - '0';

	movzx	edx, BYTE PTR [ecx+1]
	add	ecx, 1
	cmp	edi, 2
	lea	eax, DWORD PTR [edx+eax*8-48]
	jl	SHORT $LL23@check_esca
$LN73@check_esca:

; 646  :     if (!utf8 && c > 255) *errorcodeptr = ERR51;

	test	ebp, ebp
	jne	$LN86@check_esca
	cmp	eax, 255				; 000000ffH
	jle	$LN86@check_esca
	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	pop	esi
	pop	edi
	mov	DWORD PTR [edx], 51			; 00000033H

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN20@check_esca:

; 647  :     break;
; 648  : 
; 649  :     /* \x is complicated. \x{ddd} is a character number which can be greater
; 650  :     than 0xff in utf8 mode, but only if the ddd are hex digits. If not, { is
; 651  :     treated as a data character. */
; 652  : 
; 653  :     case 'x':
; 654  :     if (ptr[1] == '{')

	cmp	BYTE PTR [ecx+1], 123			; 0000007bH
	mov	bl, 8
	jne	$LN81@check_esca

; 655  :       {
; 656  :       const uschar *pt = ptr + 2;
; 657  :       int count = 0;
; 658  : 
; 659  :       c = 0;
; 660  :       while ((digitab[*pt] & ctype_xdigit) != 0)

	movzx	esi, BYTE PTR [ecx+2]
	lea	edi, DWORD PTR [ecx+2]
	xor	edx, edx
	xor	eax, eax
	test	BYTE PTR _digitab[esi], bl
	je	SHORT $LN17@check_esca
	npad	7
$LL18@check_esca:

; 661  :         {
; 662  :         register int cc = *pt++;

	add	edi, 1

; 663  :         if (c == 0 && cc == '0') continue;     /* Leading zeroes */

	test	eax, eax
	jne	SHORT $LN16@check_esca
	cmp	esi, 48					; 00000030H
	je	SHORT $LN75@check_esca
$LN16@check_esca:

; 664  :         count++;

	add	edx, 1

; 665  : 
; 666  : #ifndef EBCDIC  /* ASCII coding */
; 667  :         if (cc >= 'a') cc -= 32;               /* Convert to upper case */

	cmp	esi, 97					; 00000061H
	jl	SHORT $LN15@check_esca
	sub	esi, 32					; 00000020H
$LN15@check_esca:

; 668  :         c = (c << 4) + cc - ((cc < 'A')? '0' : ('A' - 10));

	xor	ebx, ebx
	cmp	esi, 65					; 00000041H
	setge	bl
	shl	eax, 4
	sub	ebx, 1
	and	ebx, -7					; fffffff9H
	add	ebx, 55					; 00000037H
	sub	eax, ebx
	add	eax, esi
	mov	bl, 8
$LN75@check_esca:
	movzx	esi, BYTE PTR [edi]
	test	BYTE PTR _digitab[esi], bl
	jne	SHORT $LL18@check_esca
$LN17@check_esca:

; 669  : #else           /* EBCDIC coding */
; 670  :         if (cc >= 'a' && cc <= 'z') cc += 64;  /* Convert to upper case */
; 671  :         c = (c << 4) + cc - ((cc >= '0')? '0' : ('A' - 10));
; 672  : #endif
; 673  :         }
; 674  : 
; 675  :       if (*pt == '}')

	cmp	BYTE PTR [edi], 125			; 0000007dH
	jne	SHORT $LN79@check_esca

; 676  :         {
; 677  :         if (c < 0 || count > (utf8? 8 : 2)) *errorcodeptr = ERR34;

	test	eax, eax
	jl	SHORT $LN12@check_esca
	neg	ebp
	sbb	ebp, ebp
	and	ebp, 6
	add	ebp, 2
	cmp	edx, ebp
	jle	SHORT $LN13@check_esca
$LN12@check_esca:
	mov	ecx, DWORD PTR _errorcodeptr$[esp+16]
	mov	DWORD PTR [ecx], 34			; 00000022H
$LN13@check_esca:

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+16]
	pop	esi
	mov	ecx, edi
	pop	edi
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN79@check_esca:

; 678  :         ptr = pt;
; 679  :         break;

	mov	edi, DWORD PTR _i$[esp+20]
$LN81@check_esca:

; 680  :         }
; 681  : 
; 682  :       /* If the sequence of hex digits does not end with '}', then we don't
; 683  :       recognize this construct; fall through to the normal \x handling. */
; 684  :       }
; 685  : 
; 686  :     /* Read just a single-byte hex-defined char */
; 687  : 
; 688  :     c = 0;

	xor	eax, eax
$LL11@check_esca:

; 689  :     while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)

	movzx	edx, BYTE PTR [ecx+1]
	add	edi, 1
	test	BYTE PTR _digitab[edx], bl
	je	$LN86@check_esca

; 690  :       {
; 691  :       int cc;                               /* Some compilers don't like ++ */
; 692  :       cc = *(++ptr);                        /* in initializers */

	movzx	esi, BYTE PTR [ecx+1]
	add	ecx, 1

; 693  : #ifndef EBCDIC  /* ASCII coding */
; 694  :       if (cc >= 'a') cc -= 32;              /* Convert to upper case */

	cmp	esi, 97					; 00000061H
	jl	SHORT $LN9@check_esca
	sub	esi, 32					; 00000020H
$LN9@check_esca:

; 695  :       c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));

	xor	edx, edx
	cmp	esi, 65					; 00000041H
	setge	dl
	shl	eax, 4
	sub	edx, 1
	and	edx, -7					; fffffff9H
	add	edx, 55					; 00000037H
	sub	eax, edx
	add	eax, esi
	cmp	edi, 2
	jl	SHORT $LL11@check_esca

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+16]
	pop	esi
	pop	edi
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN8@check_esca:

; 696  : #else           /* EBCDIC coding */
; 697  :       if (cc <= 'z') cc += 64;              /* Convert to upper case */
; 698  :       c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
; 699  : #endif
; 700  :       }
; 701  :     break;
; 702  : 
; 703  :     /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
; 704  :     This coding is ASCII-specific, but then the whole concept of \cx is
; 705  :     ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
; 706  : 
; 707  :     case 'c':
; 708  :     c = *(++ptr);

	movzx	eax, BYTE PTR [ecx+1]
	add	ecx, 1

; 709  :     if (c == 0)

	test	eax, eax
	jne	SHORT $LN7@check_esca

; 710  :       {
; 711  :       *errorcodeptr = ERR2;

	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	pop	esi
	pop	edi
	mov	DWORD PTR [edx], 2

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN7@check_esca:

; 712  :       break;
; 713  :       }
; 714  : 
; 715  : #ifndef EBCDIC  /* ASCII coding */
; 716  :     if (c >= 'a' && c <= 'z') c -= 32;

	lea	edx, DWORD PTR [eax-97]
	cmp	edx, 25					; 00000019H
	ja	SHORT $LN6@check_esca
	sub	eax, 32					; 00000020H
$LN6@check_esca:

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+16]
	pop	esi
	pop	edi
	pop	ebp
	xor	eax, 64					; 00000040H
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
$LN82@check_esca:

; 717  :     c ^= 0x40;
; 718  : #else           /* EBCDIC coding */
; 719  :     if (c >= 'a' && c <= 'z') c += 64;
; 720  :     c ^= 0xC0;
; 721  : #endif
; 722  :     break;
; 723  : 
; 724  :     /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
; 725  :     other alphanumeric following \ is an error if PCRE_EXTRA was set;
; 726  :     otherwise, for Perl compatibility, it is a literal. This code looks a bit
; 727  :     odd, but there used to be some cases other than the default, and there may
; 728  :     be again in future, so I haven't "optimized" it. */
; 729  : 
; 730  :     default:
; 731  :     if ((options & PCRE_EXTRA) != 0) switch(c)

	test	bl, 64					; 00000040H
	je	SHORT $LN86@check_esca

; 732  :       {
; 733  :       default:
; 734  :       *errorcodeptr = ERR3;

	mov	edx, DWORD PTR _errorcodeptr$[esp+16]
	mov	DWORD PTR [edx], 3
$LN86@check_esca:
	pop	esi
	pop	edi
$LN83@check_esca:

; 735  :       break;
; 736  :       }
; 737  :     break;
; 738  :     }
; 739  :   }
; 740  : 
; 741  : *ptrptr = ptr;

	mov	edx, DWORD PTR _ptrptr$[esp+8]
	pop	ebp
	mov	DWORD PTR [edx], ecx
	pop	ebx

; 742  : return c;
; 743  : }

	pop	ecx
	ret	0
	npad	2
$LN89@check_esca:
	DD	$LN80@check_esca
	DD	$LN32@check_esca
	DD	$LN50@check_esca
	DD	$LN8@check_esca
	DD	$LN49@check_esca
	DD	$LN20@check_esca
	DD	$LN82@check_esca
$LN78@check_esca:
	DB	0
	DB	1
	DB	1
	DB	1
	DB	1
	DB	1
	DB	1
	DB	1
	DB	1
	DB	1
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	2
	DB	6
	DB	2
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	2
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	3
	DB	6
	DB	6
	DB	6
	DB	4
	DB	6
	DB	6
	DB	6
	DB	6
	DB	2
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	6
	DB	2
	DB	6
	DB	6
	DB	5
_check_escape ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _is_counted_repeat
_TEXT	SEGMENT
_is_counted_repeat PROC					; COMDAT
; _p$ = eax

; 858  : if ((digitab[*p++] & ctype_digit) == 0) return FALSE;

	movzx	ecx, BYTE PTR [eax]
	mov	cl, BYTE PTR _digitab[ecx]
	mov	dl, 4
	and	cl, dl
	add	eax, 1
	test	cl, cl
	jne	SHORT $LN12@is_counted
$LN16@is_counted:
	xor	eax, eax

; 869  : }

	ret	0
$LN12@is_counted:

; 859  : while ((digitab[*p] & ctype_digit) != 0) p++;

	movzx	ecx, BYTE PTR [eax]
	test	BYTE PTR _digitab[ecx], dl
	je	SHORT $LN7@is_counted
$LL8@is_counted:
	movzx	ecx, BYTE PTR [eax+1]
	add	eax, 1
	test	BYTE PTR _digitab[ecx], dl
	jne	SHORT $LL8@is_counted
$LN7@is_counted:

; 860  : if (*p == '}') return TRUE;

	mov	cl, BYTE PTR [eax]
	cmp	cl, 125					; 0000007dH
	jne	SHORT $LN6@is_counted
$LN17@is_counted:
	mov	eax, 1

; 869  : }

	ret	0
$LN6@is_counted:

; 861  : 
; 862  : if (*p++ != ',') return FALSE;

	add	eax, 1
	cmp	cl, 44					; 0000002cH
	jne	SHORT $LN16@is_counted

; 863  : if (*p == '}') return TRUE;

	mov	cl, BYTE PTR [eax]
	cmp	cl, 125					; 0000007dH
	je	SHORT $LN17@is_counted

; 864  : 
; 865  : if ((digitab[*p++] & ctype_digit) == 0) return FALSE;

	movzx	ecx, cl
	mov	cl, BYTE PTR _digitab[ecx]
	and	cl, dl
	add	eax, 1
	test	cl, cl
	je	SHORT $LN16@is_counted

; 866  : while ((digitab[*p] & ctype_digit) != 0) p++;

	movzx	ecx, BYTE PTR [eax]
	test	BYTE PTR _digitab[ecx], dl
	je	SHORT $LN1@is_counted
	npad	6
$LL2@is_counted:
	movzx	ecx, BYTE PTR [eax+1]
	add	eax, 1
	test	BYTE PTR _digitab[ecx], dl
	jne	SHORT $LL2@is_counted
$LN1@is_counted:

; 867  : 
; 868  : return (*p == '}');

	xor	edx, edx
	cmp	BYTE PTR [eax], 125			; 0000007dH
	sete	dl
	mov	eax, edx

; 869  : }

	ret	0
_is_counted_repeat ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _read_repeat_counts
_TEXT	SEGMENT
_minp$ = 8						; size = 4
_maxp$ = 12						; size = 4
_read_repeat_counts PROC				; COMDAT
; _p$ = eax
; _errorcodeptr$ = edi

; 895  : int min = 0;
; 896  : int max = -1;
; 897  : 
; 898  : /* Read the minimum value and do a paranoid check: a negative value indicates
; 899  : an integer overflow. */
; 900  : 
; 901  : while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';

	movzx	ecx, BYTE PTR [eax]
	push	ebx
	push	esi
	mov	ebx, 4
	xor	esi, esi
	or	edx, -1
	test	BYTE PTR _digitab[ecx], bl
	je	SHORT $LN20@read_repea
	npad	9
$LL12@read_repea:
	lea	esi, DWORD PTR [esi+esi*4]
	add	eax, 1
	lea	esi, DWORD PTR [ecx+esi*2-48]
	movzx	ecx, BYTE PTR [eax]
	test	BYTE PTR _digitab[ecx], bl
	jne	SHORT $LL12@read_repea

; 902  : if (min < 0 || min > 65535)

	test	esi, esi
	jl	SHORT $LN9@read_repea
	cmp	esi, 65535				; 0000ffffH
	jg	SHORT $LN9@read_repea
$LN20@read_repea:

; 905  :   return p;
; 906  :   }
; 907  : 
; 908  : /* Read the maximum value if there is one, and again do a paranoid on its size.
; 909  : Also, max must not be less than min. */
; 910  : 
; 911  : if (*p == '}') max = min; else

	cmp	BYTE PTR [eax], 125			; 0000007dH
	jne	SHORT $LN8@read_repea
	mov	edx, esi
$LN1@read_repea:

; 925  :       return p;
; 926  :       }
; 927  :     }
; 928  :   }
; 929  : 
; 930  : /* Fill in the required variables, and pass back the pointer to the terminating
; 931  : '}'. */
; 932  : 
; 933  : *minp = min;

	mov	ecx, DWORD PTR _minp$[esp+4]
	mov	DWORD PTR [ecx], esi

; 934  : *maxp = max;

	mov	ecx, DWORD PTR _maxp$[esp+4]
	pop	esi
	mov	DWORD PTR [ecx], edx
	pop	ebx

; 935  : return p;
; 936  : }

	ret	0
$LN8@read_repea:

; 912  :   {
; 913  :   if (*(++p) != '}')

	mov	cl, BYTE PTR [eax+1]
	add	eax, 1
	cmp	cl, 125					; 0000007dH
	je	SHORT $LN1@read_repea

; 914  :     {
; 915  :     max = 0;
; 916  :     while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';

	movzx	ecx, cl
	xor	edx, edx
	test	BYTE PTR _digitab[ecx], bl
	je	SHORT $LN22@read_repea
	npad	1
$LL5@read_repea:
	lea	edx, DWORD PTR [edx+edx*4]
	add	eax, 1
	lea	edx, DWORD PTR [ecx+edx*2-48]
	movzx	ecx, BYTE PTR [eax]
	test	BYTE PTR _digitab[ecx], bl
	jne	SHORT $LL5@read_repea

; 917  :     if (max < 0 || max > 65535)

	test	edx, edx
	jl	SHORT $LN9@read_repea
	cmp	edx, 65535				; 0000ffffH
	jg	SHORT $LN9@read_repea
$LN22@read_repea:

; 918  :       {
; 919  :       *errorcodeptr = ERR5;
; 920  :       return p;
; 921  :       }
; 922  :     if (max < min)

	cmp	edx, esi
	jge	SHORT $LN1@read_repea
	pop	esi

; 923  :       {
; 924  :       *errorcodeptr = ERR4;

	mov	DWORD PTR [edi], ebx
	pop	ebx

; 935  : return p;
; 936  : }

	ret	0
$LN9@read_repea:
	pop	esi

; 903  :   {
; 904  :   *errorcodeptr = ERR5;

	mov	DWORD PTR [edi], 5
	pop	ebx

; 935  : return p;
; 936  : }

	ret	0
_read_repeat_counts ENDP
_TEXT	ENDS
EXTRN	_strncmp:PROC
; Function compile flags: /Ogtpy
;	COMDAT _find_parens
_TEXT	SEGMENT
_lorn$ = 8						; size = 4
_xmode$ = 12						; size = 4
_find_parens PROC					; COMDAT
; _ptr$ = ecx
; _count$ = eax
; _name$ = ebx

; 964  : {

	push	ebp
	mov	ebp, DWORD PTR _lorn$[esp]
	push	esi
	push	edi
	mov	esi, ecx
	mov	edi, eax

; 965  : const uschar *thisname;
; 966  : 
; 967  : for (; *ptr != 0; ptr++)

	mov	al, BYTE PTR [esi]
	test	al, al
	je	$LN38@find_paren
$LL40@find_paren:

; 968  :   {
; 969  :   int term;
; 970  : 
; 971  :   /* Skip over backslashed characters and also entire \Q...\E */
; 972  : 
; 973  :   if (*ptr == '\\')

	cmp	al, 92					; 0000005cH
	jne	SHORT $LN37@find_paren

; 974  :     {
; 975  :     if (*(++ptr) == 0) return -1;

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	je	$LN38@find_paren

; 976  :     if (*ptr == 'Q') for (;;)

	cmp	al, 81					; 00000051H
	jne	$LN39@find_paren
	npad	1
$LL32@find_paren:

; 977  :       {
; 978  :       while (*(++ptr) != 0 && *ptr != '\\');

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	je	$LN38@find_paren
	cmp	al, 92					; 0000005cH
	jne	SHORT $LL32@find_paren

; 979  :       if (*ptr == 0) return -1;

	test	al, al
	je	$LN38@find_paren

; 980  :       if (*(++ptr) == 'E') break;

	add	esi, 1
	cmp	BYTE PTR [esi], 69			; 00000045H
	jne	SHORT $LL32@find_paren

; 981  :       }
; 982  :     continue;

	jmp	$LN39@find_paren
$LN37@find_paren:

; 983  :     }
; 984  : 
; 985  :   /* Skip over character classes */
; 986  : 
; 987  :   if (*ptr == '[')

	cmp	al, 91					; 0000005bH
	jne	SHORT $LN28@find_paren

; 988  :     {
; 989  :     while (*(++ptr) != ']')

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	cmp	al, 93					; 0000005dH
	je	$LN39@find_paren
	npad	7
$LL27@find_paren:

; 990  :       {
; 991  :       if (*ptr == 0) return -1;

	test	al, al
	je	SHORT $LN38@find_paren

; 992  :       if (*ptr == '\\')

	cmp	al, 92					; 0000005cH
	jne	SHORT $LN65@find_paren

; 993  :         {
; 994  :         if (*(++ptr) == 0) return -1;

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	je	SHORT $LN38@find_paren

; 995  :         if (*ptr == 'Q') for (;;)

	cmp	al, 81					; 00000051H
	jne	SHORT $LN65@find_paren
$LL19@find_paren:

; 996  :           {
; 997  :           while (*(++ptr) != 0 && *ptr != '\\');

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	je	SHORT $LN38@find_paren
	cmp	al, 92					; 0000005cH
	jne	SHORT $LL19@find_paren

; 998  :           if (*ptr == 0) return -1;

	test	al, al
	je	SHORT $LN38@find_paren

; 999  :           if (*(++ptr) == 'E') break;

	add	esi, 1
	cmp	BYTE PTR [esi], 69			; 00000045H
	jne	SHORT $LL19@find_paren
$LN65@find_paren:

; 988  :     {
; 989  :     while (*(++ptr) != ']')

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	cmp	al, 93					; 0000005dH
	jne	SHORT $LL27@find_paren

; 1000 :           }
; 1001 :         continue;
; 1002 :         }
; 1003 :       }
; 1004 :     continue;

	jmp	$LN39@find_paren
$LN28@find_paren:

; 1005 :     }
; 1006 : 
; 1007 :   /* Skip comments in /x mode */
; 1008 : 
; 1009 :   if (xmode && *ptr == '#')

	cmp	DWORD PTR _xmode$[esp+8], 0
	je	SHORT $LN15@find_paren
	cmp	al, 35					; 00000023H
	jne	SHORT $LN15@find_paren
	npad	6
$LL14@find_paren:

; 1010 :     {
; 1011 :     while (*(++ptr) != 0 && *ptr != '\n');

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	je	SHORT $LN38@find_paren
	cmp	al, 10					; 0000000aH
	jne	SHORT $LL14@find_paren

; 1012 :     if (*ptr == 0) return -1;

	test	al, al
	jne	$LN39@find_paren
$LN38@find_paren:
	pop	edi
	pop	esi

; 1044 :     return count;
; 1045 :   }
; 1046 : 
; 1047 : return -1;

	or	eax, -1
	pop	ebp

; 1048 : }

	ret	0
$LN15@find_paren:

; 1013 :     continue;
; 1014 :     }
; 1015 : 
; 1016 :   /* An opening parens must now be a real metacharacter */
; 1017 : 
; 1018 :   if (*ptr != '(') continue;

	cmp	al, 40					; 00000028H
	jne	$LN39@find_paren

; 1019 :   if (ptr[1] != '?' && ptr[1] != '*')

	mov	al, BYTE PTR [esi+1]
	cmp	al, 63					; 0000003fH
	je	SHORT $LN10@find_paren
	cmp	al, 42					; 0000002aH
	je	SHORT $LN10@find_paren

; 1020 :     {
; 1021 :     count++;

	add	edi, 1

; 1022 :     if (name == NULL && count == lorn) return count;

	test	ebx, ebx
	jne	SHORT $LN39@find_paren
	cmp	edi, ebp

; 1023 :     continue;

	jmp	SHORT $LN68@find_paren
$LN10@find_paren:

; 1024 :     }
; 1025 : 
; 1026 :   ptr += 2;

	add	esi, 2

; 1027 :   if (*ptr == 'P') ptr++;                      /* Allow optional P */

	cmp	BYTE PTR [esi], 80			; 00000050H
	jne	SHORT $LN66@find_paren
	add	esi, 1
$LN66@find_paren:

; 1028 : 
; 1029 :   /* We have to disambiguate (?<! and (?<= from (?<name> */
; 1030 : 
; 1031 :   if ((*ptr != '<' || ptr[1] == '!' || ptr[1] == '=') &&
; 1032 :        *ptr != '\'')

	mov	cl, BYTE PTR [esi]
	cmp	cl, 60					; 0000003cH
	jne	SHORT $LN6@find_paren
	mov	al, BYTE PTR [esi+1]
	cmp	al, 33					; 00000021H
	je	SHORT $LN6@find_paren
	cmp	al, 61					; 0000003dH
	jne	SHORT $LN7@find_paren
$LN6@find_paren:
	cmp	cl, 39					; 00000027H
	jne	SHORT $LN39@find_paren
$LN7@find_paren:

; 1033 :     continue;
; 1034 : 
; 1035 :   count++;

	add	edi, 1

; 1036 : 
; 1037 :   if (name == NULL && count == lorn) return count;

	test	ebx, ebx
	jne	SHORT $LN5@find_paren
	cmp	edi, ebp
	je	SHORT $LN60@find_paren
$LN5@find_paren:

; 1038 :   term = *ptr++;

	movzx	eax, cl
	add	esi, 1

; 1039 :   if (term == '<') term = '>';

	cmp	eax, 60					; 0000003cH
	jne	SHORT $LN4@find_paren
	mov	eax, 62					; 0000003eH
$LN4@find_paren:

; 1040 :   thisname = ptr;
; 1041 :   while (*ptr != term) ptr++;

	movzx	edx, BYTE PTR [esi]
	cmp	edx, eax
	mov	ecx, esi
	je	SHORT $LN2@find_paren
$LL3@find_paren:
	movzx	edx, BYTE PTR [esi+1]
	add	esi, 1
	cmp	edx, eax
	jne	SHORT $LL3@find_paren
$LN2@find_paren:

; 1042 :   if (name != NULL && lorn == ptr - thisname &&
; 1043 :       strncmp((const char *)name, (const char *)thisname, lorn) == 0)

	test	ebx, ebx
	je	SHORT $LN39@find_paren
	mov	eax, esi
	sub	eax, ecx
	cmp	ebp, eax
	jne	SHORT $LN39@find_paren
	push	ebp
	push	ecx
	push	ebx
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
$LN68@find_paren:
	je	SHORT $LN60@find_paren
$LN39@find_paren:

; 965  : const uschar *thisname;
; 966  : 
; 967  : for (; *ptr != 0; ptr++)

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	jne	$LL40@find_paren
	pop	edi
	pop	esi

; 1044 :     return count;
; 1045 :   }
; 1046 : 
; 1047 : return -1;

	or	eax, -1
	pop	ebp

; 1048 : }

	ret	0
$LN60@find_paren:

; 1022 :     if (name == NULL && count == lorn) return count;

	mov	eax, edi
	pop	edi
	pop	esi
	pop	ebp

; 1048 : }

	ret	0
_find_parens ENDP
_TEXT	ENDS
EXTRN	__pcre_OP_lengths:BYTE
; Function compile flags: /Ogtpy
;	COMDAT _first_significant_code
_TEXT	SEGMENT
_first_significant_code PROC				; COMDAT
; _code$ = eax
; _options$ = edi
; _optbit$ = esi
; _skipassert$ = ebx

; 1076 : for (;;)
; 1077 :   {
; 1078 :   switch ((int)*code)

	movzx	edx, BYTE PTR [eax]
	mov	ecx, edx
	sub	ecx, 4
	cmp	ecx, 97					; 00000061H
	push	ebp
	ja	SHORT $LN14@first_sign
	npad	2
$LL15@first_sign:
	movzx	ecx, BYTE PTR $LN22@first_sign[ecx]
	jmp	DWORD PTR $LN25@first_sign[ecx*4]
$LN11@first_sign:

; 1079 :     {
; 1080 :     case OP_OPT:
; 1081 :     if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))

	test	esi, esi
	jle	SHORT $LN23@first_sign
	movzx	ecx, BYTE PTR [eax+1]
	mov	edx, DWORD PTR [edi]
	mov	ebp, ecx
	and	edx, esi
	and	ebp, esi
	cmp	ebp, edx
	je	SHORT $LN23@first_sign

; 1082 :       *options = (int)code[1];

	mov	DWORD PTR [edi], ecx
$LN23@first_sign:

; 1083 :     code += 2;

	add	eax, 2

; 1084 :     break;

	jmp	SHORT $LN12@first_sign
$LN9@first_sign:

; 1085 : 
; 1086 :     case OP_ASSERT_NOT:
; 1087 :     case OP_ASSERTBACK:
; 1088 :     case OP_ASSERTBACK_NOT:
; 1089 :     if (!skipassert) return code;

	test	ebx, ebx
	je	SHORT $LN14@first_sign
	npad	3
$LL7@first_sign:

; 1090 :     do code += GET(code, 1); while (*code == 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 $LL7@first_sign

; 1091 :     code += _pcre_OP_lengths[*code];

	movzx	edx, BYTE PTR [eax]
	movzx	ecx, BYTE PTR __pcre_OP_lengths[edx]
	add	eax, ecx

; 1092 :     break;

	jmp	SHORT $LN12@first_sign
$LN4@first_sign:

; 1093 : 
; 1094 :     case OP_WORD_BOUNDARY:
; 1095 :     case OP_NOT_WORD_BOUNDARY:
; 1096 :     if (!skipassert) return code;

	test	ebx, ebx
	je	SHORT $LN14@first_sign
$LN3@first_sign:

; 1097 :     /* Fall through */
; 1098 : 
; 1099 :     case OP_CALLOUT:
; 1100 :     case OP_CREF:
; 1101 :     case OP_RREF:
; 1102 :     case OP_DEF:
; 1103 :     code += _pcre_OP_lengths[*code];

	movzx	edx, BYTE PTR __pcre_OP_lengths[edx]
	add	eax, edx
$LN12@first_sign:
	movzx	edx, BYTE PTR [eax]
	mov	ecx, edx
	sub	ecx, 4
	cmp	ecx, 97					; 00000061H
	jbe	SHORT $LL15@first_sign
$LN14@first_sign:
	pop	ebp

; 1104 :     break;
; 1105 : 
; 1106 :     default:
; 1107 :     return code;
; 1108 :     }
; 1109 :   }
; 1110 : /* Control never reaches here */
; 1111 : }

	ret	0
	npad	3
$LN25@first_sign:
	DD	$LN4@first_sign
	DD	$LN11@first_sign
	DD	$LN3@first_sign
	DD	$LN9@first_sign
	DD	$LN14@first_sign
$LN22@first_sign:
	DB	0
	DB	0
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	1
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	2
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	3
	DB	3
	DB	3
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	4
	DB	2
	DB	2
	DB	2
_first_significant_code ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _find_fixedlength
_TEXT	SEGMENT
_code$ = 8						; size = 4
_options$ = 12						; size = 4
_find_fixedlength PROC					; COMDAT

; 1134 : {

	push	ebx
	push	ebp
	push	esi

; 1135 : int length = -1;
; 1136 : 
; 1137 : register int branchlength = 0;
; 1138 : register uschar *cc = code + 1 + LINK_SIZE;

	mov	esi, DWORD PTR _code$[esp+8]

; 1139 : 
; 1140 : /* Scan along the opcodes for this branch. If we get to the end of the
; 1141 : branch, check the length against that of the other branches. */
; 1142 : 
; 1143 : for (;;)
; 1144 :   {
; 1145 :   int d;
; 1146 :   register int op = *cc;

	mov	cl, BYTE PTR [esi+3]
	add	esi, 3
	movzx	eax, cl
	push	edi
	or	ebx, -1
	xor	edi, edi

; 1147 :   switch (op)

	cmp	eax, 101				; 00000065H
	ja	$LN48@find_fixed
	mov	ebp, DWORD PTR _options$[esp+12]
	npad	13
$LL35@find_fixed:
	movzx	edx, BYTE PTR $LN45@find_fixed[eax]
	jmp	DWORD PTR $LN51@find_fixed[edx*4]
$LN31@find_fixed:

; 1148 :     {
; 1149 :     case OP_CBRA:
; 1150 :     case OP_BRA:
; 1151 :     case OP_ONCE:
; 1152 :     case OP_COND:
; 1153 :     d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options);

	xor	ecx, ecx
	cmp	eax, 94					; 0000005eH
	setne	cl
	push	ebp
	sub	ecx, 1
	and	ecx, 2
	add	ecx, esi
	push	ecx
	call	_find_fixedlength
	add	esp, 8

; 1154 :     if (d < 0) return d;

	test	eax, eax
	jl	$LN34@find_fixed

; 1155 :     branchlength += d;

	add	edi, eax
$LL29@find_fixed:

; 1156 :     do cc += GET(cc, 1); while (*cc == OP_ALT);

	xor	edx, edx
	mov	dh, BYTE PTR [esi+1]
	mov	dl, BYTE PTR [esi+2]
	add	esi, edx
	cmp	BYTE PTR [esi], 83			; 00000053H
	je	SHORT $LL29@find_fixed

; 1157 :     cc += 1 + LINK_SIZE;

	add	esi, 3

; 1158 :     break;

	jmp	$LN6@find_fixed
$LN26@find_fixed:

; 1159 : 
; 1160 :     /* Reached end of a branch; if it's a ket it is the end of a nested
; 1161 :     call. If it's ALT it is an alternation in a nested call. If it is
; 1162 :     END it's the end of the outer call. All can be handled by the same code. */
; 1163 : 
; 1164 :     case OP_ALT:
; 1165 :     case OP_KET:
; 1166 :     case OP_KETRMAX:
; 1167 :     case OP_KETRMIN:
; 1168 :     case OP_END:
; 1169 :     if (length < 0) length = branchlength;

	test	ebx, ebx
	jge	SHORT $LN25@find_fixed
	mov	ebx, edi
	jmp	SHORT $LN23@find_fixed
$LN25@find_fixed:

; 1170 :       else if (length != branchlength) return -1;

	cmp	ebx, edi
	jne	$LN48@find_fixed
$LN23@find_fixed:

; 1171 :     if (*cc != OP_ALT) return length;

	cmp	cl, 83					; 00000053H
	jne	$LN43@find_fixed

; 1172 :     cc += 1 + LINK_SIZE;

	add	esi, 3

; 1173 :     branchlength = 0;

	xor	edi, edi

; 1174 :     break;

	jmp	$LN6@find_fixed
	npad	4
$LL20@find_fixed:

; 1175 : 
; 1176 :     /* Skip over assertive subpatterns */
; 1177 : 
; 1178 :     case OP_ASSERT:
; 1179 :     case OP_ASSERT_NOT:
; 1180 :     case OP_ASSERTBACK:
; 1181 :     case OP_ASSERTBACK_NOT:
; 1182 :     do cc += GET(cc, 1); while (*cc == OP_ALT);

	xor	eax, eax
	mov	ah, BYTE PTR [esi+1]
	mov	al, BYTE PTR [esi+2]
	add	esi, eax
	cmp	BYTE PTR [esi], 83			; 00000053H
	je	SHORT $LL20@find_fixed
$LN18@find_fixed:

; 1183 :     /* Fall through */
; 1184 : 
; 1185 :     /* Skip over things that don't match chars */
; 1186 : 
; 1187 :     case OP_REVERSE:
; 1188 :     case OP_CREF:
; 1189 :     case OP_RREF:
; 1190 :     case OP_DEF:
; 1191 :     case OP_OPT:
; 1192 :     case OP_CALLOUT:
; 1193 :     case OP_SOD:
; 1194 :     case OP_SOM:
; 1195 :     case OP_EOD:
; 1196 :     case OP_EODN:
; 1197 :     case OP_CIRC:
; 1198 :     case OP_DOLL:
; 1199 :     case OP_NOT_WORD_BOUNDARY:
; 1200 :     case OP_WORD_BOUNDARY:
; 1201 :     cc += _pcre_OP_lengths[*cc];

	movzx	ecx, BYTE PTR [esi]
	movzx	edx, BYTE PTR __pcre_OP_lengths[ecx]
	add	esi, edx

; 1202 :     break;

	jmp	SHORT $LN6@find_fixed
$LN16@find_fixed:

; 1203 : 
; 1204 :     /* Handle literal characters */
; 1205 : 
; 1206 :     case OP_CHAR:
; 1207 :     case OP_CHARNC:
; 1208 :     case OP_NOT:
; 1209 :     branchlength++;

	add	edi, 1

; 1210 :     cc += 2;

	add	esi, 2

; 1211 : #ifdef SUPPORT_UTF8
; 1212 :     if ((options & PCRE_UTF8) != 0)
; 1213 :       {
; 1214 :       while ((*cc & 0xc0) == 0x80) cc++;
; 1215 :       }
; 1216 : #endif
; 1217 :     break;

	jmp	SHORT $LN6@find_fixed
$LN15@find_fixed:

; 1218 : 
; 1219 :     /* Handle exact repetitions. The count is already in characters, but we
; 1220 :     need to skip over a multibyte character in UTF8 mode.  */
; 1221 : 
; 1222 :     case OP_EXACT:
; 1223 :     branchlength += GET2(cc,1);

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

; 1224 :     cc += 4;

	add	esi, 4

; 1225 : #ifdef SUPPORT_UTF8
; 1226 :     if ((options & PCRE_UTF8) != 0)
; 1227 :       {
; 1228 :       while((*cc & 0x80) == 0x80) cc++;
; 1229 :       }
; 1230 : #endif
; 1231 :     break;

	jmp	SHORT $LN6@find_fixed
$LN14@find_fixed:

; 1235 :     if (cc[3] == OP_PROP || cc[3] == OP_NOTPROP) cc += 2;

	mov	al, BYTE PTR [esi+3]
	xor	ecx, ecx
	mov	ch, BYTE PTR [esi+1]
	mov	cl, BYTE PTR [esi+2]
	add	edi, ecx
	cmp	al, 15					; 0000000fH
	je	SHORT $LN12@find_fixed
	cmp	al, 14					; 0000000eH
	jne	SHORT $LN13@find_fixed
$LN12@find_fixed:

; 1232 : 
; 1233 :     case OP_TYPEEXACT:
; 1234 :     branchlength += GET2(cc,1);

	add	esi, 2
$LN13@find_fixed:

; 1236 :     cc += 4;

	add	esi, 4

; 1237 :     break;

	jmp	SHORT $LN6@find_fixed
$LN11@find_fixed:

; 1238 : 
; 1239 :     /* Handle single-char matchers */
; 1240 : 
; 1241 :     case OP_PROP:
; 1242 :     case OP_NOTPROP:
; 1243 :     cc += 2;

	add	esi, 2
$LN10@find_fixed:

; 1244 :     /* Fall through */
; 1245 : 
; 1246 :     case OP_NOT_DIGIT:
; 1247 :     case OP_DIGIT:
; 1248 :     case OP_NOT_WHITESPACE:
; 1249 :     case OP_WHITESPACE:
; 1250 :     case OP_NOT_WORDCHAR:
; 1251 :     case OP_WORDCHAR:
; 1252 :     case OP_ANY:
; 1253 :     branchlength++;

	add	edi, 1

; 1254 :     cc++;

	add	esi, 1

; 1255 :     break;

	jmp	SHORT $LN6@find_fixed
$LN8@find_fixed:

; 1261 : 
; 1262 :     /* Check a class for variable quantification */
; 1263 : 
; 1264 : #ifdef SUPPORT_UTF8
; 1265 :     case OP_XCLASS:
; 1266 :     cc += GET(cc, 1) - 33;
; 1267 :     /* Fall through */
; 1268 : #endif
; 1269 : 
; 1270 :     case OP_CLASS:
; 1271 :     case OP_NCLASS:
; 1272 :     cc += 33;
; 1273 : 
; 1274 :     switch (*cc)

	movzx	eax, BYTE PTR [esi+33]
	add	esi, 33					; 00000021H
	add	eax, -69				; ffffffbbH
	cmp	eax, 7
	ja	SHORT $LN2@find_fixed
	movzx	edx, BYTE PTR $LN46@find_fixed[eax]
	jmp	DWORD PTR $LN52@find_fixed[edx*4]
$LN4@find_fixed:

; 1275 :       {
; 1276 :       case OP_CRSTAR:
; 1277 :       case OP_CRMINSTAR:
; 1278 :       case OP_CRQUERY:
; 1279 :       case OP_CRMINQUERY:
; 1280 :       return -1;
; 1281 : 
; 1282 :       case OP_CRRANGE:
; 1283 :       case OP_CRMINRANGE:
; 1284 :       if (GET2(cc,1) != GET2(cc,3)) return -1;

	movzx	ecx, BYTE PTR [esi+2]
	xor	edx, edx
	mov	dh, BYTE PTR [esi+3]
	xor	eax, eax
	mov	ah, BYTE PTR [esi+1]
	mov	dl, BYTE PTR [esi+4]
	or	eax, ecx
	cmp	eax, edx
	jne	SHORT $LN48@find_fixed

; 1285 :       branchlength += GET2(cc,1);

	add	edi, eax

; 1286 :       cc += 5;

	add	esi, 5

; 1287 :       break;

	jmp	SHORT $LN6@find_fixed
$LN2@find_fixed:

; 1288 : 
; 1289 :       default:
; 1290 :       branchlength++;

	add	edi, 1
$LN6@find_fixed:

; 1139 : 
; 1140 : /* Scan along the opcodes for this branch. If we get to the end of the
; 1141 : branch, check the length against that of the other branches. */
; 1142 : 
; 1143 : for (;;)
; 1144 :   {
; 1145 :   int d;
; 1146 :   register int op = *cc;

	mov	cl, BYTE PTR [esi]
	movzx	eax, cl

; 1147 :   switch (op)

	cmp	eax, 101				; 00000065H
	jbe	$LL35@find_fixed
$LN48@find_fixed:

; 1291 :       }
; 1292 :     break;
; 1293 : 
; 1294 :     /* Anything else is variable length */
; 1295 : 
; 1296 :     default:
; 1297 :     return -1;

	or	eax, -1
$LN34@find_fixed:
	pop	edi
	pop	esi
	pop	ebp
	pop	ebx

; 1298 :     }
; 1299 :   }
; 1300 : /* Control never gets here */
; 1301 : }

	ret	0
$LN43@find_fixed:
	pop	edi
	pop	esi
	pop	ebp

; 1171 :     if (*cc != OP_ALT) return length;

	mov	eax, ebx
	pop	ebx

; 1298 :     }
; 1299 :   }
; 1300 : /* Control never gets here */
; 1301 : }

	ret	0
$LN9@find_fixed:
	pop	edi
	pop	esi
	pop	ebp

; 1256 : 
; 1257 :     /* The single-byte matcher isn't allowed */
; 1258 : 
; 1259 :     case OP_ANYBYTE:
; 1260 :     return -2;

	mov	eax, -2					; fffffffeH
	pop	ebx

; 1298 :     }
; 1299 :   }
; 1300 : /* Control never gets here */
; 1301 : }

	ret	0
	npad	3
$LN51@find_fixed:
	DD	$LN26@find_fixed
	DD	$LN18@find_fixed
	DD	$LN10@find_fixed
	DD	$LN9@find_fixed
	DD	$LN11@find_fixed
	DD	$LN16@find_fixed
	DD	$LN15@find_fixed
	DD	$LN14@find_fixed
	DD	$LN8@find_fixed
	DD	$LL20@find_fixed
	DD	$LN31@find_fixed
	DD	$LN48@find_fixed
$LN45@find_fixed:
	DB	0
	DB	1
	DB	1
	DB	11					; 0000000bH
	DB	1
	DB	1
	DB	2
	DB	2
	DB	2
	DB	2
	DB	2
	DB	2
	DB	2
	DB	3
	DB	4
	DB	4
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	1
	DB	1
	DB	1
	DB	1
	DB	1
	DB	5
	DB	5
	DB	5
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	6
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	7
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	8
	DB	8
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	1
	DB	0
	DB	0
	DB	0
	DB	0
	DB	9
	DB	9
	DB	9
	DB	9
	DB	1
	DB	10					; 0000000aH
	DB	10					; 0000000aH
	DB	10					; 0000000aH
	DB	10					; 0000000aH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	1
	DB	1
	DB	1
	npad	2
$LN52@find_fixed:
	DD	$LN48@find_fixed
	DD	$LN4@find_fixed
	DD	$LN2@find_fixed
$LN46@find_fixed:
	DB	0
	DB	0
	DB	2
	DB	2
	DB	0
	DB	0
	DB	1
	DB	1
_find_fixedlength ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _find_bracket
_TEXT	SEGMENT
_find_bracket PROC					; COMDAT
; _code$ = eax
; _number$ = esi

; 1324 : for (;;)
; 1325 :   {
; 1326 :   register int c = *code;

	movzx	ecx, BYTE PTR [eax]

; 1327 :   if (c == OP_END) return NULL;

	test	ecx, ecx
	push	ebx
	je	SHORT $LN21@find_brack
	mov	bl, BYTE PTR __pcre_OP_lengths+94
	npad	2
$LL16@find_brack:

; 1328 : 
; 1329 :   /* XCLASS is used for classes that cannot be represented just by a bit
; 1330 :   map. This includes negated single high-valued characters. The length in
; 1331 :   the table is zero; the actual length is stored in the compiled code. */
; 1332 : 
; 1333 :   if (c == OP_XCLASS) code += GET(code, 1);

	cmp	ecx, 79					; 0000004fH
	jne	SHORT $LN13@find_brack
	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+1]
	mov	cl, BYTE PTR [eax+2]
	jmp	SHORT $LN24@find_brack
$LN13@find_brack:

; 1334 : 
; 1335 :   /* Handle capturing bracket */
; 1336 : 
; 1337 :   else if (c == OP_CBRA)

	cmp	ecx, 94					; 0000005eH
	jne	SHORT $LN11@find_brack

; 1338 :     {
; 1339 :     int n = GET2(code, 1+LINK_SIZE);
; 1340 :     if (n == number) return (uschar *)code;

	xor	edx, edx
	mov	dh, BYTE PTR [eax+3]
	mov	dl, BYTE PTR [eax+4]
	cmp	edx, esi
	je	SHORT $LN15@find_brack

; 1341 :     code += _pcre_OP_lengths[c];

	movzx	ecx, bl

; 1342 :     }
; 1343 : 
; 1344 :   /* Otherwise, we can get the item's length from the table, except that for
; 1345 :   repeated character types, we have to test for \p and \P, which have an extra
; 1346 :   two bytes of parameters. */
; 1347 : 
; 1348 :   else

	jmp	SHORT $LN24@find_brack
$LN11@find_brack:

; 1349 :     {
; 1350 :     switch(c)

	lea	edx, DWORD PTR [ecx-56]
	cmp	edx, 12					; 0000000cH
	ja	SHORT $LN2@find_brack
	movzx	edx, BYTE PTR $LN23@find_brack[edx]
	jmp	DWORD PTR $LN28@find_brack[edx*4]
$LN6@find_brack:

; 1351 :       {
; 1352 :       case OP_TYPESTAR:
; 1353 :       case OP_TYPEMINSTAR:
; 1354 :       case OP_TYPEPLUS:
; 1355 :       case OP_TYPEMINPLUS:
; 1356 :       case OP_TYPEQUERY:
; 1357 :       case OP_TYPEMINQUERY:
; 1358 :       case OP_TYPEPOSSTAR:
; 1359 :       case OP_TYPEPOSPLUS:
; 1360 :       case OP_TYPEPOSQUERY:
; 1361 :       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;

	mov	dl, BYTE PTR [eax+1]

; 1362 :       break;

	jmp	SHORT $LN27@find_brack
$LN3@find_brack:

; 1363 : 
; 1364 :       case OP_TYPEUPTO:
; 1365 :       case OP_TYPEMINUPTO:
; 1366 :       case OP_TYPEEXACT:
; 1367 :       case OP_TYPEPOSUPTO:
; 1368 :       if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;

	mov	dl, BYTE PTR [eax+3]
$LN27@find_brack:
	cmp	dl, 15					; 0000000fH
	je	SHORT $LN1@find_brack
	cmp	dl, 14					; 0000000eH
	jne	SHORT $LN2@find_brack
$LN1@find_brack:
	add	eax, 2
$LN2@find_brack:

; 1369 :       break;
; 1370 :       }
; 1371 : 
; 1372 :     /* Add in the fixed length from the table */
; 1373 : 
; 1374 :     code += _pcre_OP_lengths[c];

	movzx	ecx, BYTE PTR __pcre_OP_lengths[ecx]
$LN24@find_brack:
	add	eax, ecx
	movzx	ecx, BYTE PTR [eax]
	test	ecx, ecx
	jne	SHORT $LL16@find_brack
$LN21@find_brack:

; 1327 :   if (c == OP_END) return NULL;

	xor	eax, eax
$LN15@find_brack:
	pop	ebx

; 1375 : 
; 1376 :   /* In UTF-8 mode, opcodes that are followed by a character may be followed by
; 1377 :   a multi-byte character. The length in the table is a minimum, so we have to
; 1378 :   arrange to skip the extra bytes. */
; 1379 : 
; 1380 : #ifdef SUPPORT_UTF8
; 1381 :     if (utf8) switch(c)
; 1382 :       {
; 1383 :       case OP_CHAR:
; 1384 :       case OP_CHARNC:
; 1385 :       case OP_EXACT:
; 1386 :       case OP_UPTO:
; 1387 :       case OP_MINUPTO:
; 1388 :       case OP_POSUPTO:
; 1389 :       case OP_STAR:
; 1390 :       case OP_MINSTAR:
; 1391 :       case OP_POSSTAR:
; 1392 :       case OP_PLUS:
; 1393 :       case OP_MINPLUS:
; 1394 :       case OP_POSPLUS:
; 1395 :       case OP_QUERY:
; 1396 :       case OP_MINQUERY:
; 1397 :       case OP_POSQUERY:
; 1398 :       if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
; 1399 :       break;
; 1400 :       }
; 1401 : #endif
; 1402 :     }
; 1403 :   }
; 1404 : }

	ret	0
$LN28@find_brack:
	DD	$LN6@find_brack
	DD	$LN3@find_brack
$LN23@find_brack:
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	1
	DB	1
	DB	1
	DB	0
	DB	0
	DB	0
	DB	1
_find_bracket ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _find_recurse
_TEXT	SEGMENT
_find_recurse PROC					; COMDAT
; _code$ = eax

; 1425 : for (;;)
; 1426 :   {
; 1427 :   register int c = *code;

	movzx	ecx, BYTE PTR [eax]

; 1428 :   if (c == OP_END) return NULL;

	test	ecx, ecx
	je	SHORT $LN19@find_recur
$LL14@find_recur:

; 1429 :   if (c == OP_RECURSE) return code;

	cmp	ecx, 81					; 00000051H
	je	SHORT $LN13@find_recur

; 1430 : 
; 1431 :   /* XCLASS is used for classes that cannot be represented just by a bit
; 1432 :   map. This includes negated single high-valued characters. The length in
; 1433 :   the table is zero; the actual length is stored in the compiled code. */
; 1434 : 
; 1435 :   if (c == OP_XCLASS) code += GET(code, 1);

	cmp	ecx, 79					; 0000004fH
	jne	SHORT $LN10@find_recur
	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+1]
	mov	cl, BYTE PTR [eax+2]

; 1436 : 
; 1437 :   /* Otherwise, we can get the item's length from the table, except that for
; 1438 :   repeated character types, we have to test for \p and \P, which have an extra
; 1439 :   two bytes of parameters. */
; 1440 : 
; 1441 :   else

	jmp	SHORT $LN22@find_recur
$LN10@find_recur:

; 1442 :     {
; 1443 :     switch(c)

	lea	edx, DWORD PTR [ecx-56]
	cmp	edx, 12					; 0000000cH
	ja	SHORT $LN2@find_recur
	movzx	edx, BYTE PTR $LN21@find_recur[edx]
	jmp	DWORD PTR $LN26@find_recur[edx*4]
$LN6@find_recur:

; 1444 :       {
; 1445 :       case OP_TYPESTAR:
; 1446 :       case OP_TYPEMINSTAR:
; 1447 :       case OP_TYPEPLUS:
; 1448 :       case OP_TYPEMINPLUS:
; 1449 :       case OP_TYPEQUERY:
; 1450 :       case OP_TYPEMINQUERY:
; 1451 :       case OP_TYPEPOSSTAR:
; 1452 :       case OP_TYPEPOSPLUS:
; 1453 :       case OP_TYPEPOSQUERY:
; 1454 :       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;

	mov	dl, BYTE PTR [eax+1]

; 1455 :       break;

	jmp	SHORT $LN25@find_recur
$LN3@find_recur:

; 1456 : 
; 1457 :       case OP_TYPEPOSUPTO:
; 1458 :       case OP_TYPEUPTO:
; 1459 :       case OP_TYPEMINUPTO:
; 1460 :       case OP_TYPEEXACT:
; 1461 :       if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;

	mov	dl, BYTE PTR [eax+3]
$LN25@find_recur:
	cmp	dl, 15					; 0000000fH
	je	SHORT $LN1@find_recur
	cmp	dl, 14					; 0000000eH
	jne	SHORT $LN2@find_recur
$LN1@find_recur:
	add	eax, 2
$LN2@find_recur:

; 1462 :       break;
; 1463 :       }
; 1464 : 
; 1465 :     /* Add in the fixed length from the table */
; 1466 : 
; 1467 :     code += _pcre_OP_lengths[c];

	movzx	ecx, BYTE PTR __pcre_OP_lengths[ecx]
$LN22@find_recur:
	add	eax, ecx
	movzx	ecx, BYTE PTR [eax]
	test	ecx, ecx
	jne	SHORT $LL14@find_recur
$LN19@find_recur:

; 1428 :   if (c == OP_END) return NULL;

	xor	eax, eax
$LN13@find_recur:

; 1468 : 
; 1469 :     /* In UTF-8 mode, opcodes that are followed by a character may be followed
; 1470 :     by a multi-byte character. The length in the table is a minimum, so we have
; 1471 :     to arrange to skip the extra bytes. */
; 1472 : 
; 1473 : #ifdef SUPPORT_UTF8
; 1474 :     if (utf8) switch(c)
; 1475 :       {
; 1476 :       case OP_CHAR:
; 1477 :       case OP_CHARNC:
; 1478 :       case OP_EXACT:
; 1479 :       case OP_UPTO:
; 1480 :       case OP_MINUPTO:
; 1481 :       case OP_POSUPTO:
; 1482 :       case OP_STAR:
; 1483 :       case OP_MINSTAR:
; 1484 :       case OP_POSSTAR:
; 1485 :       case OP_PLUS:
; 1486 :       case OP_MINPLUS:
; 1487 :       case OP_POSPLUS:
; 1488 :       case OP_QUERY:
; 1489 :       case OP_MINQUERY:
; 1490 :       case OP_POSQUERY:
; 1491 :       if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
; 1492 :       break;
; 1493 :       }
; 1494 : #endif
; 1495 :     }
; 1496 :   }
; 1497 : }

	ret	0
	npad	3
$LN26@find_recur:
	DD	$LN6@find_recur
	DD	$LN3@find_recur
$LN21@find_recur:
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	1
	DB	1
	DB	1
	DB	0
	DB	0
	DB	0
	DB	1
_find_recurse ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _could_be_empty_branch
_TEXT	SEGMENT
_code$ = 8						; size = 4
_endcode$ = 12						; size = 4
_utf8$ = 16						; size = 4
_could_be_empty_branch PROC				; COMDAT

; 1524 : register int c;
; 1525 : for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
; 1526 :      code < endcode;
; 1527 :      code = first_significant_code(code + _pcre_OP_lengths[c], NULL, 0, TRUE))

	mov	ecx, DWORD PTR _code$[esp-4]
	movzx	eax, BYTE PTR [ecx]
	movzx	eax, BYTE PTR __pcre_OP_lengths[eax]
	push	ebx
	push	ebp
	push	esi
	push	edi
	add	eax, ecx
	mov	ebx, 1
	xor	esi, esi
	xor	edi, edi
	call	_first_significant_code
	mov	ebp, DWORD PTR _endcode$[esp+12]
	mov	esi, eax
	cmp	esi, ebp
	jae	$LN35@could_be_e
$LL37@could_be_e:

; 1528 :   {
; 1529 :   const uschar *ccode;
; 1530 : 
; 1531 :   c = *code;

	movzx	eax, BYTE PTR [esi]

; 1532 : 
; 1533 :   /* Skip over forward assertions; the other assertions are skipped by
; 1534 :   first_significant_code() with a TRUE final argument. */
; 1535 : 
; 1536 :   if (c == OP_ASSERT)

	cmp	eax, 87					; 00000057H
	jne	SHORT $LN34@could_be_e
$LL33@could_be_e:

; 1537 :     {
; 1538 :     do code += GET(code, 1); while (*code == OP_ALT);

	xor	ecx, ecx
	mov	ch, BYTE PTR [esi+1]
	mov	cl, BYTE PTR [esi+2]
	add	esi, ecx
	cmp	BYTE PTR [esi], 83			; 00000053H
	je	SHORT $LL33@could_be_e

; 1539 :     c = *code;
; 1540 :     continue;

	jmp	$LN50@could_be_e
$LN34@could_be_e:

; 1541 :     }
; 1542 : 
; 1543 :   /* Groups with zero repeats can of course be empty; skip them. */
; 1544 : 
; 1545 :   if (c == OP_BRAZERO || c == OP_BRAMINZERO)

	cmp	eax, 102				; 00000066H
	je	$LN29@could_be_e
	cmp	eax, 103				; 00000067H
	je	$LN29@could_be_e

; 1550 :     continue;
; 1551 :     }
; 1552 : 
; 1553 :   /* For other groups, scan the branches. */
; 1554 : 
; 1555 :   if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)

	cmp	eax, 93					; 0000005dH
	je	SHORT $LN24@could_be_e
	cmp	eax, 94					; 0000005eH
	je	SHORT $LN24@could_be_e
	cmp	eax, 92					; 0000005cH
	je	SHORT $LN24@could_be_e
	cmp	eax, 95					; 0000005fH
	je	SHORT $LN24@could_be_e

; 1573 :     }
; 1574 : 
; 1575 :   /* Handle the other opcodes */
; 1576 : 
; 1577 :   switch (c)

	lea	ecx, DWORD PTR [eax-6]
	cmp	ecx, 80					; 00000050H
	ja	$LN36@could_be_e
	movzx	edx, BYTE PTR $LN48@could_be_e[ecx]
	jmp	DWORD PTR $LN53@could_be_e[edx*4]
$LN15@could_be_e:

; 1578 :     {
; 1579 :     /* Check for quantifiers after a class. XCLASS is used for classes that
; 1580 :     cannot be represented just by a bit map. This includes negated single
; 1581 :     high-valued characters. The length in _pcre_OP_lengths[] is zero; the
; 1582 :     actual length is stored in the compiled code, so we must update "code"
; 1583 :     here. */
; 1584 : 
; 1585 : #ifdef SUPPORT_UTF8
; 1586 :     case OP_XCLASS:
; 1587 :     ccode = code += GET(code, 1);
; 1588 :     goto CHECK_CLASS_REPEAT;
; 1589 : #endif
; 1590 : 
; 1591 :     case OP_CLASS:
; 1592 :     case OP_NCLASS:
; 1593 :     ccode = code + 33;
; 1594 : 
; 1595 : #ifdef SUPPORT_UTF8
; 1596 :     CHECK_CLASS_REPEAT:
; 1597 : #endif
; 1598 : 
; 1599 :     switch (*ccode)

	movzx	ecx, BYTE PTR [esi+33]
	add	ecx, -69				; ffffffbbH
	cmp	ecx, 7
	ja	SHORT $LN46@could_be_e
	movzx	ecx, BYTE PTR $LN49@could_be_e[ecx]
	jmp	DWORD PTR $LN54@could_be_e[ecx*4]
$LN10@could_be_e:

; 1600 :       {
; 1601 :       case OP_CRSTAR:            /* These could be empty; continue */
; 1602 :       case OP_CRMINSTAR:
; 1603 :       case OP_CRQUERY:
; 1604 :       case OP_CRMINQUERY:
; 1605 :       break;
; 1606 : 
; 1607 :       default:                   /* Non-repeat => class must match */
; 1608 :       case OP_CRPLUS:            /* These repeats aren't empty */
; 1609 :       case OP_CRMINPLUS:
; 1610 :       return FALSE;
; 1611 : 
; 1612 :       case OP_CRRANGE:
; 1613 :       case OP_CRMINRANGE:
; 1614 :       if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */

	xor	edx, edx
	mov	dh, BYTE PTR [esi+34]
	mov	dl, BYTE PTR [esi+35]
	test	edx, edx
	jle	$LN36@could_be_e
$LN46@could_be_e:
	pop	edi
	pop	esi
	pop	ebp

; 1570 :     if (!empty_branch) return FALSE;   /* All branches are non-empty */

	xor	eax, eax
	pop	ebx

; 1697 : }

	ret	0
$LN7@could_be_e:

; 1615 :       break;
; 1616 :       }
; 1617 :     break;
; 1618 : 
; 1619 :     /* Opcodes that must match a character */
; 1620 : 
; 1621 :     case OP_PROP:
; 1622 :     case OP_NOTPROP:
; 1623 :     case OP_EXTUNI:
; 1624 :     case OP_NOT_DIGIT:
; 1625 :     case OP_DIGIT:
; 1626 :     case OP_NOT_WHITESPACE:
; 1627 :     case OP_WHITESPACE:
; 1628 :     case OP_NOT_WORDCHAR:
; 1629 :     case OP_WORDCHAR:
; 1630 :     case OP_ANY:
; 1631 :     case OP_ANYBYTE:
; 1632 :     case OP_CHAR:
; 1633 :     case OP_CHARNC:
; 1634 :     case OP_NOT:
; 1635 :     case OP_PLUS:
; 1636 :     case OP_MINPLUS:
; 1637 :     case OP_POSPLUS:
; 1638 :     case OP_EXACT:
; 1639 :     case OP_NOTPLUS:
; 1640 :     case OP_NOTMINPLUS:
; 1641 :     case OP_NOTPOSPLUS:
; 1642 :     case OP_NOTEXACT:
; 1643 :     case OP_TYPEPLUS:
; 1644 :     case OP_TYPEMINPLUS:
; 1645 :     case OP_TYPEPOSPLUS:
; 1646 :     case OP_TYPEEXACT:
; 1647 :     return FALSE;
; 1648 : 
; 1649 :     /* These are going to continue, as they may be empty, but we have to
; 1650 :     fudge the length for the \p and \P cases. */
; 1651 : 
; 1652 :     case OP_TYPESTAR:
; 1653 :     case OP_TYPEMINSTAR:
; 1654 :     case OP_TYPEPOSSTAR:
; 1655 :     case OP_TYPEQUERY:
; 1656 :     case OP_TYPEMINQUERY:
; 1657 :     case OP_TYPEPOSQUERY:
; 1658 :     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;

	mov	cl, BYTE PTR [esi+1]

; 1659 :     break;

	jmp	SHORT $LN51@could_be_e
$LN4@could_be_e:

; 1660 : 
; 1661 :     /* Same for these */
; 1662 : 
; 1663 :     case OP_TYPEUPTO:
; 1664 :     case OP_TYPEMINUPTO:
; 1665 :     case OP_TYPEPOSUPTO:
; 1666 :     if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;

	mov	cl, BYTE PTR [esi+3]
$LN51@could_be_e:
	cmp	cl, 15					; 0000000fH
	je	SHORT $LN2@could_be_e
	cmp	cl, 14					; 0000000eH
	jne	SHORT $LN36@could_be_e
$LN2@could_be_e:
	add	esi, 2

; 1667 :     break;
; 1668 : 
; 1669 :     /* End of branch */
; 1670 : 
; 1671 :     case OP_KET:
; 1672 :     case OP_KETRMAX:
; 1673 :     case OP_KETRMIN:
; 1674 :     case OP_ALT:
; 1675 :     return TRUE;
; 1676 : 
; 1677 :     /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
; 1678 :     MINUPTO, and POSUPTO may be followed by a multibyte character */
; 1679 : 
; 1680 : #ifdef SUPPORT_UTF8
; 1681 :     case OP_STAR:
; 1682 :     case OP_MINSTAR:
; 1683 :     case OP_POSSTAR:
; 1684 :     case OP_QUERY:
; 1685 :     case OP_MINQUERY:
; 1686 :     case OP_POSQUERY:
; 1687 :     case OP_UPTO:
; 1688 :     case OP_MINUPTO:
; 1689 :     case OP_POSUPTO:
; 1690 :     if (utf8) while ((code[2] & 0xc0) == 0x80) code++;
; 1691 :     break;
; 1692 : #endif
; 1693 :     }
; 1694 :   }

	jmp	SHORT $LN36@could_be_e
$LN24@could_be_e:

; 1556 :     {
; 1557 :     BOOL empty_branch;
; 1558 :     if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */

	xor	eax, eax
	mov	ah, BYTE PTR [esi+1]
	mov	al, BYTE PTR [esi+2]
	test	eax, eax
	je	SHORT $LN35@could_be_e

; 1559 : 
; 1560 :     /* Scan a closed bracket */
; 1561 : 
; 1562 :     empty_branch = FALSE;

	xor	edi, edi
$LL22@could_be_e:

; 1563 :     do
; 1564 :       {
; 1565 :       if (!empty_branch && could_be_empty_branch(code, endcode, utf8))

	test	edi, edi
	jne	SHORT $LN19@could_be_e
	mov	ecx, DWORD PTR _utf8$[esp+12]
	push	ecx
	push	ebp
	push	esi
	call	_could_be_empty_branch
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN19@could_be_e

; 1566 :         empty_branch = TRUE;

	mov	edi, 1
$LN19@could_be_e:

; 1567 :       code += GET(code, 1);

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

; 1568 :       }
; 1569 :     while (*code == OP_ALT);

	cmp	BYTE PTR [esi], 83			; 00000053H
	je	SHORT $LL22@could_be_e

; 1570 :     if (!empty_branch) return FALSE;   /* All branches are non-empty */

	test	edi, edi
	je	SHORT $LN46@could_be_e

; 1571 :     c = *code;
; 1572 :     continue;

	jmp	SHORT $LN50@could_be_e
$LN29@could_be_e:

; 1546 :     {
; 1547 :     code += _pcre_OP_lengths[c];

	movzx	eax, BYTE PTR __pcre_OP_lengths[eax]
	add	esi, eax
	npad	4
$LL28@could_be_e:

; 1548 :     do code += GET(code, 1); while (*code == OP_ALT);

	xor	ecx, ecx
	mov	ch, BYTE PTR [esi+1]
	mov	cl, BYTE PTR [esi+2]
	add	esi, ecx
	cmp	BYTE PTR [esi], 83			; 00000053H
	je	SHORT $LL28@could_be_e
$LN50@could_be_e:

; 1549 :     c = *code;

	movzx	eax, BYTE PTR [esi]
$LN36@could_be_e:

; 1524 : register int c;
; 1525 : for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
; 1526 :      code < endcode;
; 1527 :      code = first_significant_code(code + _pcre_OP_lengths[c], NULL, 0, TRUE))

	movzx	eax, BYTE PTR __pcre_OP_lengths[eax]
	add	eax, esi
	mov	ebx, 1
	xor	esi, esi
	xor	edi, edi
	call	_first_significant_code
	mov	esi, eax
	cmp	esi, ebp
	jb	$LL37@could_be_e
$LN35@could_be_e:
	pop	edi
	pop	esi
	pop	ebp

; 1695 : 
; 1696 : return TRUE;

	mov	eax, 1
	pop	ebx

; 1697 : }

	ret	0
	npad	3
$LN53@could_be_e:
	DD	$LN46@could_be_e
	DD	$LN7@could_be_e
	DD	$LN4@could_be_e
	DD	$LN15@could_be_e
	DD	$LN35@could_be_e
	DD	$LN36@could_be_e
$LN48@could_be_e:
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	0
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	0
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	0
	DB	0
	DB	0
	DB	5
	DB	5
	DB	0
	DB	0
	DB	5
	DB	5
	DB	5
	DB	5
	DB	0
	DB	5
	DB	0
	DB	5
	DB	5
	DB	5
	DB	5
	DB	0
	DB	0
	DB	5
	DB	5
	DB	5
	DB	5
	DB	0
	DB	5
	DB	0
	DB	5
	DB	5
	DB	1
	DB	1
	DB	0
	DB	0
	DB	1
	DB	1
	DB	2
	DB	2
	DB	0
	DB	1
	DB	0
	DB	1
	DB	2
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	3
	DB	3
	DB	5
	DB	5
	DB	5
	DB	5
	DB	4
	DB	4
	DB	4
	DB	4
	npad	3
$LN54@could_be_e:
	DD	$LN36@could_be_e
	DD	$LN10@could_be_e
	DD	$LN46@could_be_e
$LN49@could_be_e:
	DB	0
	DB	0
	DB	2
	DB	2
	DB	0
	DB	0
	DB	1
	DB	1
_could_be_empty_branch ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _could_be_empty
_TEXT	SEGMENT
_code$ = 8						; size = 4
_could_be_empty PROC					; COMDAT
; _endcode$ = ebx
; _bcptr$ = eax
; _utf8$ = edi

; 1722 : {

	push	ebp
	mov	ebp, DWORD PTR _code$[esp]
	push	esi
	mov	esi, eax

; 1723 : while (bcptr != NULL && bcptr->current >= code)

	test	esi, esi
	je	SHORT $LN2@could_be_e@2
	npad	4
$LL3@could_be_e@2:
	mov	eax, DWORD PTR [esi+4]
	cmp	eax, ebp
	jb	SHORT $LN2@could_be_e@2

; 1724 :   {
; 1725 :   if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;

	push	edi
	push	ebx
	push	eax
	call	_could_be_empty_branch
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN7@could_be_e@2

; 1726 :   bcptr = bcptr->outer;

	mov	esi, DWORD PTR [esi]
	test	esi, esi
	jne	SHORT $LL3@could_be_e@2
$LN2@could_be_e@2:
	pop	esi

; 1727 :   }
; 1728 : return TRUE;

	mov	eax, 1
	pop	ebp

; 1729 : }

	ret	0
$LN7@could_be_e@2:
	pop	esi

; 1724 :   {
; 1725 :   if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;

	xor	eax, eax
	pop	ebp

; 1729 : }

	ret	0
_could_be_empty ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _check_posix_syntax
_TEXT	SEGMENT
_endptr$ = 8						; size = 4
_check_posix_syntax PROC				; COMDAT
; _ptr$ = eax

; 1767 : int terminator;          /* Don't combine these lines; the Solaris cc */
; 1768 : terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */

	movzx	edx, BYTE PTR [eax+1]
	add	eax, 1

; 1769 : for (++ptr; *ptr != 0; ptr++)

	mov	cl, BYTE PTR [eax+1]
	add	eax, 1
	test	cl, cl
	push	ebx
	je	SHORT $LN5@check_posi
	mov	bl, 93					; 0000005dH
$LL7@check_posi:

; 1770 :   {
; 1771 :   if (*ptr == '\\' && ptr[1] == ']') ptr++; else

	cmp	cl, 92					; 0000005cH
	jne	SHORT $LN4@check_posi
	cmp	BYTE PTR [eax+1], bl
	jne	SHORT $LN4@check_posi

; 1769 : for (++ptr; *ptr != 0; ptr++)

	add	eax, 1

; 1770 :   {
; 1771 :   if (*ptr == '\\' && ptr[1] == ']') ptr++; else

	jmp	SHORT $LN6@check_posi
$LN4@check_posi:

; 1772 :     {
; 1773 :     if (*ptr == ']') return FALSE;

	cmp	cl, bl
	je	SHORT $LN5@check_posi

; 1774 :     if (*ptr == terminator && ptr[1] == ']')

	movzx	ecx, cl
	cmp	ecx, edx
	jne	SHORT $LN6@check_posi
	cmp	BYTE PTR [eax+1], bl
	je	SHORT $LN12@check_posi
$LN6@check_posi:

; 1769 : for (++ptr; *ptr != 0; ptr++)

	mov	cl, BYTE PTR [eax+1]
	add	eax, 1
	test	cl, cl
	jne	SHORT $LL7@check_posi
$LN5@check_posi:

; 1778 :       }
; 1779 :     }
; 1780 :   }
; 1781 : return FALSE;

	xor	eax, eax
	pop	ebx

; 1782 : }

	ret	0
$LN12@check_posi:

; 1775 :       {
; 1776 :       *endptr = ptr;

	mov	edx, DWORD PTR _endptr$[esp]
	mov	DWORD PTR [edx], eax

; 1777 :       return TRUE;

	mov	eax, 1
	pop	ebx

; 1782 : }

	ret	0
_check_posix_syntax ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _check_posix_name
_TEXT	SEGMENT
_ptr$ = 8						; size = 4
_check_posix_name PROC					; COMDAT
; _len$ = ebx

; 1803 : {

	push	ebp
	mov	ebp, DWORD PTR _ptr$[esp]
	push	esi
	push	edi

; 1804 : const char *pn = posix_names;

	mov	edi, OFFSET _posix_names

; 1805 : register int yield = 0;

	xor	esi, esi
	npad	2
$LL3@check_posi@2:

; 1806 : while (posix_name_lengths[yield] != 0)
; 1807 :   {
; 1808 :   if (len == posix_name_lengths[yield] &&
; 1809 :     strncmp((const char *)ptr, pn, len) == 0) return yield;

	movzx	eax, BYTE PTR _posix_name_lengths[esi]
	cmp	ebx, eax
	jne	SHORT $LN1@check_posi@2
	push	ebx
	push	edi
	push	ebp
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN7@check_posi@2
$LN1@check_posi@2:

; 1810 :   pn += posix_name_lengths[yield] + 1;

	movzx	ecx, BYTE PTR _posix_name_lengths[esi]

; 1811 :   yield++;

	add	esi, 1
	cmp	BYTE PTR _posix_name_lengths[esi], 0
	lea	edi, DWORD PTR [edi+ecx+1]
	jne	SHORT $LL3@check_posi@2
	pop	edi
	pop	esi

; 1812 :   }
; 1813 : return -1;

	or	eax, -1
	pop	ebp

; 1814 : }

	ret	0
$LN7@check_posi@2:
	pop	edi

; 1806 : while (posix_name_lengths[yield] != 0)
; 1807 :   {
; 1808 :   if (len == posix_name_lengths[yield] &&
; 1809 :     strncmp((const char *)ptr, pn, len) == 0) return yield;

	mov	eax, esi
	pop	esi
	pop	ebp

; 1814 : }

	ret	0
_check_posix_name ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _adjust_recurse
_TEXT	SEGMENT
_group$ = 8						; size = 4
_adjust$ = 12						; size = 4
_cd$ = 16						; size = 4
_save_hwm$ = 20						; size = 4
_adjust_recurse PROC					; COMDAT

; 1851 : uschar *ptr = group;
; 1852 : 
; 1853 : while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)

	mov	eax, DWORD PTR _group$[esp-4]
	push	ebx
	mov	ebx, DWORD PTR _adjust$[esp]
	push	esi
	push	edi
	mov	edi, DWORD PTR _cd$[esp+8]
	call	_find_recurse
	mov	esi, eax
	test	esi, esi
	je	$LN7@adjust_rec
	push	ebp
	npad	1
$LL8@adjust_rec:

; 1854 :   {
; 1855 :   int offset;
; 1856 :   uschar *hc;
; 1857 : 
; 1858 :   /* See if this recursion is on the forward reference list. If so, adjust the
; 1859 :   reference. */
; 1860 : 
; 1861 :   for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)

	mov	ecx, DWORD PTR _save_hwm$[esp+12]
	mov	ebp, DWORD PTR [edi+32]
	cmp	ecx, ebp
	jae	SHORT $LN16@adjust_rec
	mov	eax, DWORD PTR [edi+20]
	lea	edi, DWORD PTR [esi+1]
$LL6@adjust_rec:

; 1862 :     {
; 1863 :     offset = GET(hc, 0);

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

; 1864 :     if (cd->start_code + offset == ptr + 1)

	lea	ebx, DWORD PTR [eax+edx]
	cmp	ebx, edi
	je	SHORT $LN13@adjust_rec
	add	ecx, 2
	cmp	ecx, ebp
	jb	SHORT $LL6@adjust_rec
	mov	ebx, DWORD PTR _adjust$[esp+12]
	jmp	SHORT $LN17@adjust_rec
$LN13@adjust_rec:

; 1865 :       {
; 1866 :       PUT(hc, 0, offset + adjust);

	mov	ebx, DWORD PTR _adjust$[esp+12]
	lea	eax, DWORD PTR [edx+ebx]
	sar	eax, 8
	mov	BYTE PTR [ecx], al
	mov	al, bl
	add	al, dl
	mov	BYTE PTR [ecx+1], al
$LN17@adjust_rec:
	mov	edi, DWORD PTR _cd$[esp+12]
$LN16@adjust_rec:

; 1867 :       break;
; 1868 :       }
; 1869 :     }
; 1870 : 
; 1871 :   /* Otherwise, adjust the recursion offset if it's after the start of this
; 1872 :   group. */
; 1873 : 
; 1874 :   if (hc >= cd->hwm)

	cmp	ecx, DWORD PTR [edi+32]
	jb	SHORT $LN1@adjust_rec

; 1875 :     {
; 1876 :     offset = GET(ptr, 1);
; 1877 :     if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);

	mov	ecx, DWORD PTR [edi+20]
	xor	eax, eax
	mov	ah, BYTE PTR [esi+1]
	mov	al, BYTE PTR [esi+2]
	add	ecx, eax
	cmp	ecx, DWORD PTR _group$[esp+12]
	jb	SHORT $LN1@adjust_rec
	lea	edx, DWORD PTR [eax+ebx]
	sar	edx, 8
	mov	cl, bl
	add	cl, al
	mov	BYTE PTR [esi+1], dl
	mov	BYTE PTR [esi+2], cl
$LN1@adjust_rec:

; 1878 :     }
; 1879 : 
; 1880 :   ptr += 1 + LINK_SIZE;

	lea	eax, DWORD PTR [esi+3]
	call	_find_recurse
	mov	esi, eax
	test	esi, esi
	jne	SHORT $LL8@adjust_rec
	pop	ebp
$LN7@adjust_rec:
	pop	edi
	pop	esi
	pop	ebx

; 1881 :   }
; 1882 : }

	ret	0
_adjust_recurse ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _auto_callout
_TEXT	SEGMENT
_auto_callout PROC					; COMDAT
; _code$ = eax
; _ptr$ = ecx
; _cd$ = esi

; 1904 : *code++ = OP_CALLOUT;

	mov	BYTE PTR [eax], 82			; 00000052H

; 1905 : *code++ = 255;

	mov	BYTE PTR [eax+1], 255			; 000000ffH
	add	eax, 1

; 1906 : PUT(code, 0, ptr - cd->start_pattern);  /* Pattern offset */

	mov	edx, ecx
	sub	edx, DWORD PTR [esi+24]
	add	eax, 1
	sar	edx, 8
	mov	BYTE PTR [eax], dl
	sub	cl, BYTE PTR [esi+24]

; 1907 : PUT(code, LINK_SIZE, 0);                /* Default length */
; 1908 : return code + 2*LINK_SIZE;

	add	eax, 4
	mov	BYTE PTR [eax-3], cl
	xor	cl, cl
	mov	BYTE PTR [eax-2], cl
	mov	BYTE PTR [eax-1], cl

; 1909 : }

	ret	0
_auto_callout ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _complete_callout
_TEXT	SEGMENT
_cd$ = 8						; size = 4
_complete_callout PROC					; COMDAT
; _previous_callout$ = ecx
; _ptr$ = eax

; 1932 : int length = ptr - cd->start_pattern - GET(previous_callout, 2);

	xor	edx, edx
	mov	dh, BYTE PTR [ecx+2]
	mov	dl, BYTE PTR [ecx+3]
	sub	eax, edx
	mov	edx, DWORD PTR _cd$[esp-4]
	sub	eax, DWORD PTR [edx+24]

; 1933 : PUT(previous_callout, 2 + LINK_SIZE, length);

	mov	edx, eax
	sar	edx, 8
	mov	BYTE PTR [ecx+4], dl
	mov	BYTE PTR [ecx+5], al

; 1934 : }

	ret	0
_complete_callout ENDP
_TEXT	ENDS
PUBLIC	??_C@_03HPNPIJEA@?$HL0?0?$AA@			; `string'
EXTRN	__pcre_is_newline:PROC
;	COMDAT ??_C@_03HPNPIJEA@?$HL0?0?$AA@
CONST	SEGMENT
??_C@_03HPNPIJEA@?$HL0?0?$AA@ DB '{0,', 00H		; `string'
; Function compile flags: /Ogtpy
CONST	ENDS
;	COMDAT _check_auto_possessive
_TEXT	SEGMENT
_temperrorcode$5850 = -4				; size = 4
_op_code$ = 8						; size = 4
_item$ = 12						; size = 4
_utf8$ = 16						; size = 4
_ptr$ = 20						; size = 4
_options$ = 24						; size = 4
_check_auto_possessive PROC				; COMDAT
; _cd$ = edi

; 2009 : {

	push	ecx
	push	ebx

; 2010 : int next;
; 2011 : 
; 2012 : /* Skip whitespace and comments in extended mode */
; 2013 : 
; 2014 : if ((options & PCRE_EXTENDED) != 0)

	mov	ebx, DWORD PTR _options$[esp+4]
	and	ebx, 8
	push	ebp
	mov	ebp, DWORD PTR _utf8$[esp+8]
	push	esi
	mov	esi, DWORD PTR _ptr$[esp+12]
	je	$LN175@check_auto
	npad	7
$LL86@check_auto:

; 2015 :   {
; 2016 :   for (;;)
; 2017 :     {
; 2018 :     while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;

	movzx	ecx, BYTE PTR [esi]
	mov	eax, DWORD PTR [edi+12]
	test	BYTE PTR [ecx+eax], 1
	je	SHORT $LN83@check_auto
	npad	4
$LL84@check_auto:
	movzx	edx, BYTE PTR [esi+1]
	add	esi, 1
	test	BYTE PTR [edx+eax], 1
	jne	SHORT $LL84@check_auto
	mov	DWORD PTR _ptr$[esp+12], esi
$LN83@check_auto:

; 2019 :     if (*ptr == '#')

	cmp	BYTE PTR [esi], 35			; 00000023H
	jne	SHORT $LN175@check_auto

; 2020 :       {
; 2021 :       while (*(++ptr) != 0)

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	mov	DWORD PTR _ptr$[esp+12], esi
	je	SHORT $LL86@check_auto
$LL81@check_auto:

; 2022 :         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }

	mov	ecx, DWORD PTR [edi+80]
	test	ecx, ecx
	je	SHORT $LN95@check_auto
	mov	eax, DWORD PTR [edi+28]
	cmp	esi, eax
	jae	SHORT $LN170@check_auto
	push	ebp
	lea	edx, DWORD PTR [edi+84]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	je	SHORT $LN170@check_auto
$LN169@check_auto:
	add	esi, DWORD PTR [edi+84]
	mov	DWORD PTR _ptr$[esp+12], esi

; 2023 :       }
; 2024 :     else break;
; 2025 :     }

	jmp	SHORT $LL86@check_auto
$LN95@check_auto:

; 2022 :         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }

	mov	ecx, DWORD PTR [edi+84]
	mov	edx, DWORD PTR [edi+28]
	sub	edx, ecx
	cmp	esi, edx
	ja	SHORT $LN170@check_auto
	cmp	al, BYTE PTR [edi+88]
	jne	SHORT $LN170@check_auto
	cmp	ecx, 1
	je	SHORT $LN169@check_auto
	mov	al, BYTE PTR [esi+1]
	cmp	al, BYTE PTR [edi+89]
	je	SHORT $LN169@check_auto
$LN170@check_auto:

; 2020 :       {
; 2021 :       while (*(++ptr) != 0)

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	mov	DWORD PTR _ptr$[esp+12], esi
	jne	SHORT $LL81@check_auto
	jmp	$LL86@check_auto
$LN175@check_auto:

; 2026 :   }
; 2027 : 
; 2028 : /* If the next item is one that we can handle, get its value. A non-negative
; 2029 : value is a character, a negative value is an escape value. */
; 2030 : 
; 2031 : if (*ptr == '\\')

	mov	al, BYTE PTR [esi]
	cmp	al, 92					; 0000005cH
	jne	SHORT $LN77@check_auto

; 2032 :   {
; 2033 :   int temperrorcode = 0;
; 2034 :   next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);

	mov	ecx, DWORD PTR [edi+48]
	push	0
	push	ecx
	lea	edx, DWORD PTR _temperrorcode$5850[esp+24]
	push	edx
	lea	eax, DWORD PTR _ptr$[esp+24]
	push	eax
	mov	eax, DWORD PTR _options$[esp+28]
	mov	DWORD PTR _temperrorcode$5850[esp+32], 0
	call	_check_escape
	add	esp, 16					; 00000010H

; 2035 :   if (temperrorcode != 0) return FALSE;

	cmp	DWORD PTR _temperrorcode$5850[esp+16], 0
	mov	ebp, eax
	jne	$LN74@check_auto

; 2036 :   ptr++;    /* Point after the escape sequence */

	mov	esi, DWORD PTR _ptr$[esp+12]
	jmp	SHORT $LN177@check_auto
$LN77@check_auto:

; 2037 :   }
; 2038 : 
; 2039 : else if ((cd->ctypes[*ptr] & ctype_meta) == 0)

	mov	ecx, DWORD PTR [edi+12]
	movzx	ebp, al
	test	BYTE PTR [ecx+ebp], 128			; 00000080H
	jne	$LN74@check_auto
$LN177@check_auto:

; 2040 :   {
; 2041 : #ifdef SUPPORT_UTF8
; 2042 :   if (utf8) { GETCHARINC(next, ptr); } else
; 2043 : #endif
; 2044 :   next = *ptr++;

	add	esi, 1

; 2048 : 
; 2049 : /* Skip whitespace and comments in extended mode */
; 2050 : 
; 2051 : if ((options & PCRE_EXTENDED) != 0)

	test	ebx, ebx
	je	$LN67@check_auto
	npad	8
$LL71@check_auto:

; 2052 :   {
; 2053 :   for (;;)
; 2054 :     {
; 2055 :     while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;

	movzx	edx, BYTE PTR [esi]
	mov	eax, DWORD PTR [edi+12]
	test	BYTE PTR [edx+eax], 1
	je	SHORT $LN176@check_auto
	npad	4
$LL69@check_auto:
	movzx	ecx, BYTE PTR [esi+1]
	add	esi, 1
	test	BYTE PTR [ecx+eax], 1
	jne	SHORT $LL69@check_auto
$LN176@check_auto:

; 2056 :     if (*ptr == '#')

	cmp	BYTE PTR [esi], 35			; 00000023H
	jne	SHORT $LN67@check_auto

; 2057 :       {
; 2058 :       while (*(++ptr) != 0)

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	je	SHORT $LL71@check_auto
	npad	4
$LL66@check_auto:

; 2059 :         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }

	mov	ecx, DWORD PTR [edi+80]
	test	ecx, ecx
	je	SHORT $LN102@check_auto
	mov	eax, DWORD PTR [edi+28]
	cmp	esi, eax
	jae	SHORT $LN98@check_auto
	mov	edx, DWORD PTR _utf8$[esp+12]
	push	edx
	lea	edx, DWORD PTR [edi+84]
	push	edx
	push	eax
	push	ecx
	push	esi
	call	__pcre_is_newline
	add	esp, 20					; 00000014H
	test	eax, eax
	je	SHORT $LN98@check_auto
$LN157@check_auto:
	add	esi, DWORD PTR [edi+84]

; 2060 :       }
; 2061 :     else break;
; 2062 :     }

	jmp	SHORT $LL71@check_auto
$LN102@check_auto:

; 2059 :         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }

	mov	ecx, DWORD PTR [edi+84]
	mov	edx, DWORD PTR [edi+28]
	sub	edx, ecx
	cmp	esi, edx
	ja	SHORT $LN98@check_auto
	cmp	al, BYTE PTR [edi+88]
	jne	SHORT $LN98@check_auto
	cmp	ecx, 1
	je	SHORT $LN157@check_auto
	mov	al, BYTE PTR [esi+1]
	cmp	al, BYTE PTR [edi+89]
	je	SHORT $LN157@check_auto
$LN98@check_auto:

; 2057 :       {
; 2058 :       while (*(++ptr) != 0)

	mov	al, BYTE PTR [esi+1]
	add	esi, 1
	test	al, al
	jne	SHORT $LL66@check_auto
	jmp	$LL71@check_auto
$LN67@check_auto:

; 2063 :   }
; 2064 : 
; 2065 : /* If the next thing is itself optional, we have to give up. */
; 2066 : 
; 2067 : if (*ptr == '*' || *ptr == '?' || strncmp((char *)ptr, "{0,", 3) == 0)

	mov	al, BYTE PTR [esi]
	cmp	al, 42					; 0000002aH
	je	$LN74@check_auto
	cmp	al, 63					; 0000003fH
	je	$LN74@check_auto
	push	3
	push	OFFSET ??_C@_03HPNPIJEA@?$HL0?0?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	$LN74@check_auto

; 2068 :   return FALSE;
; 2069 : 
; 2070 : /* Now compare the next item with the previous opcode. If the previous is a
; 2071 : positive single character match, "item" either contains the character or, if
; 2072 : "item" is greater than 127 in utf8 mode, the character's bytes are in
; 2073 : utf8_char. */
; 2074 : 
; 2075 : 
; 2076 : /* Handle cases when the next item is a character. */
; 2077 : 
; 2078 : if (next >= 0) switch(op_code)

	test	ebp, ebp
	jl	$LN58@check_auto
	mov	ecx, DWORD PTR _op_code$[esp+12]
	lea	eax, DWORD PTR [ecx-6]
	cmp	eax, 23					; 00000017H
	ja	$LN74@check_auto
	movzx	edx, BYTE PTR $LN166@check_auto[eax]
	jmp	DWORD PTR $LN186@check_auto[edx*4]
$LN57@check_auto:

; 2079 :   {
; 2080 :   case OP_CHAR:
; 2081 : #ifdef SUPPORT_UTF8
; 2082 :   if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
; 2083 : #endif
; 2084 :   return item != next;

	xor	eax, eax
	cmp	DWORD PTR _item$[esp+12], ebp
	pop	esi
	pop	ebp
	setne	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN56@check_auto:

; 2085 : 
; 2086 :   /* For CHARNC (caseless character) we must check the other case. If we have
; 2087 :   Unicode property support, we can use it to test the other case of
; 2088 :   high-valued characters. */
; 2089 : 
; 2090 :   case OP_CHARNC:
; 2091 : #ifdef SUPPORT_UTF8
; 2092 :   if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
; 2093 : #endif
; 2094 :   if (item == next) return FALSE;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, ebp
	je	$LN74@check_auto

; 2095 : #ifdef SUPPORT_UTF8
; 2096 :   if (utf8)
; 2097 :     {
; 2098 :     unsigned int othercase;
; 2099 :     if (next < 128) othercase = cd->fcc[next]; else
; 2100 : #ifdef SUPPORT_UCP
; 2101 :     othercase = _pcre_ucp_othercase((unsigned int)next);
; 2102 : #else
; 2103 :     othercase = NOTACHAR;
; 2104 : #endif
; 2105 :     return (unsigned int)item != othercase;
; 2106 :     }
; 2107 :   else
; 2108 : #endif  /* SUPPORT_UTF8 */
; 2109 :   return (item != cd->fcc[next]);  /* Non-UTF-8 mode */

	mov	ecx, DWORD PTR [edi+4]
	movzx	edx, BYTE PTR [ecx+ebp]
	xor	ecx, ecx
	cmp	eax, edx
	setne	cl
	pop	esi
	pop	ebp
	pop	ebx
	mov	eax, ecx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN54@check_auto:

; 2110 : 
; 2111 :   /* For OP_NOT, "item" must be a single-byte character. */
; 2112 : 
; 2113 :   case OP_NOT:
; 2114 :   if (next < 0) return FALSE;  /* Not a character */
; 2115 :   if (item == next) return TRUE;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, ebp
	je	SHORT $LN104@check_auto

; 2116 :   if ((options & PCRE_CASELESS) == 0) return FALSE;

	test	BYTE PTR _options$[esp+12], 1
	je	$LN74@check_auto

; 2117 : #ifdef SUPPORT_UTF8
; 2118 :   if (utf8)
; 2119 :     {
; 2120 :     unsigned int othercase;
; 2121 :     if (next < 128) othercase = cd->fcc[next]; else
; 2122 : #ifdef SUPPORT_UCP
; 2123 :     othercase = _pcre_ucp_othercase(next);
; 2124 : #else
; 2125 :     othercase = NOTACHAR;
; 2126 : #endif
; 2127 :     return (unsigned int)item == othercase;
; 2128 :     }
; 2129 :   else
; 2130 : #endif  /* SUPPORT_UTF8 */
; 2131 :   return (item == cd->fcc[next]);  /* Non-UTF-8 mode */

	mov	edx, DWORD PTR [edi+4]
	movzx	ecx, BYTE PTR [edx+ebp]
	xor	edx, edx
	cmp	eax, ecx
	sete	dl
	pop	esi
	pop	ebp
	pop	ebx
	mov	eax, edx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN50@check_auto:

; 2132 : 
; 2133 :   case OP_DIGIT:
; 2134 :   return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;

	cmp	ebp, 127				; 0000007fH
	jg	SHORT $LN104@check_auto
	mov	eax, DWORD PTR [edi+12]
	test	BYTE PTR [eax+ebp], 4
	jmp	$LN185@check_auto
$LN49@check_auto:

; 2135 : 
; 2136 :   case OP_NOT_DIGIT:
; 2137 :   return next <= 127 && (cd->ctypes[next] & ctype_digit) != 0;

	cmp	ebp, 127				; 0000007fH
	jg	$LN74@check_auto
	mov	ecx, DWORD PTR [edi+12]
	test	BYTE PTR [ecx+ebp], 4
	je	$LN74@check_auto
$LN104@check_auto:
	pop	esi
	pop	ebp
	mov	eax, 1
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN48@check_auto:

; 2138 : 
; 2139 :   case OP_WHITESPACE:
; 2140 :   return next > 127 || (cd->ctypes[next] & ctype_space) == 0;

	cmp	ebp, 127				; 0000007fH
	jg	SHORT $LN104@check_auto
	mov	edx, DWORD PTR [edi+12]
	test	BYTE PTR [edx+ebp], 1
	jmp	$LN185@check_auto
$LN47@check_auto:

; 2141 : 
; 2142 :   case OP_NOT_WHITESPACE:
; 2143 :   return next <= 127 && (cd->ctypes[next] & ctype_space) != 0;

	cmp	ebp, 127				; 0000007fH
	jg	$LN74@check_auto
	mov	eax, DWORD PTR [edi+12]
	test	BYTE PTR [eax+ebp], 1
	je	$LN74@check_auto
	pop	esi
	pop	ebp
	mov	eax, 1
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN46@check_auto:

; 2144 : 
; 2145 :   case OP_WORDCHAR:
; 2146 :   return next > 127 || (cd->ctypes[next] & ctype_word) == 0;

	cmp	ebp, 127				; 0000007fH
	jg	SHORT $LN104@check_auto
	mov	ecx, DWORD PTR [edi+12]
	test	BYTE PTR [ecx+ebp], 16			; 00000010H
	jmp	$LN185@check_auto
$LN45@check_auto:

; 2147 : 
; 2148 :   case OP_NOT_WORDCHAR:
; 2149 :   return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;

	cmp	ebp, 127				; 0000007fH
	jg	$LN74@check_auto
	mov	edx, DWORD PTR [edi+12]
	test	BYTE PTR [edx+ebp], 16			; 00000010H
	je	$LN74@check_auto
	pop	esi
	pop	ebp
	mov	eax, 1
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN44@check_auto:

; 2150 : 
; 2151 :   case OP_HSPACE:
; 2152 :   case OP_NOT_HSPACE:
; 2153 :   switch(next)

	cmp	ebp, 6158				; 0000180eH
	jg	SHORT $LN116@check_auto
	je	SHORT $LN41@check_auto
	cmp	ebp, 160				; 000000a0H
	jg	SHORT $LN117@check_auto
	je	SHORT $LN41@check_auto
	cmp	ebp, 9
	je	SHORT $LN41@check_auto
	cmp	ebp, 32					; 00000020H
	jmp	SHORT $LN179@check_auto
$LN117@check_auto:
	cmp	ebp, 5760				; 00001680H
	jmp	SHORT $LN179@check_auto
$LN116@check_auto:
	cmp	ebp, 8287				; 0000205fH
	jg	SHORT $LN118@check_auto
	je	SHORT $LN41@check_auto
	cmp	ebp, 8192				; 00002000H
	jl	SHORT $LN40@check_auto
	cmp	ebp, 8202				; 0000200aH
	jle	SHORT $LN41@check_auto
	cmp	ebp, 8239				; 0000202fH
	jmp	SHORT $LN179@check_auto
$LN118@check_auto:
	cmp	ebp, 12288				; 00003000H
$LN179@check_auto:
	je	SHORT $LN41@check_auto
$LN40@check_auto:
	pop	esi

; 2175 :     default:
; 2176 :     return op_code == OP_HSPACE;

	xor	eax, eax
	cmp	ecx, 18					; 00000012H
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN41@check_auto:
	pop	esi

; 2154 :     {
; 2155 :     case 0x09:
; 2156 :     case 0x20:
; 2157 :     case 0xa0:
; 2158 :     case 0x1680:
; 2159 :     case 0x180e:
; 2160 :     case 0x2000:
; 2161 :     case 0x2001:
; 2162 :     case 0x2002:
; 2163 :     case 0x2003:
; 2164 :     case 0x2004:
; 2165 :     case 0x2005:
; 2166 :     case 0x2006:
; 2167 :     case 0x2007:
; 2168 :     case 0x2008:
; 2169 :     case 0x2009:
; 2170 :     case 0x200A:
; 2171 :     case 0x202f:
; 2172 :     case 0x205f:
; 2173 :     case 0x3000:
; 2174 :     return op_code != OP_HSPACE;

	xor	eax, eax
	cmp	ecx, 18					; 00000012H
	pop	ebp
	setne	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN42@check_auto:

; 2177 :     }
; 2178 : 
; 2179 :   case OP_VSPACE:
; 2180 :   case OP_NOT_VSPACE:
; 2181 :   switch(next)

	cmp	ebp, 133				; 00000085H
	jg	SHORT $LN119@check_auto
	je	SHORT $LN36@check_auto
	cmp	ebp, 10					; 0000000aH
	jl	SHORT $LN35@check_auto
	cmp	ebp, 13					; 0000000dH
	jle	SHORT $LN36@check_auto
$LN35@check_auto:
	pop	esi

; 2191 :     default:
; 2192 :     return op_code == OP_VSPACE;

	xor	eax, eax
	cmp	ecx, 20					; 00000014H
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN119@check_auto:

; 2177 :     }
; 2178 : 
; 2179 :   case OP_VSPACE:
; 2180 :   case OP_NOT_VSPACE:
; 2181 :   switch(next)

	cmp	ebp, 8232				; 00002028H
	jl	SHORT $LN35@check_auto
	cmp	ebp, 8233				; 00002029H
	jg	SHORT $LN35@check_auto
$LN36@check_auto:
	pop	esi

; 2182 :     {
; 2183 :     case 0x0a:
; 2184 :     case 0x0b:
; 2185 :     case 0x0c:
; 2186 :     case 0x0d:
; 2187 :     case 0x85:
; 2188 :     case 0x2028:
; 2189 :     case 0x2029:
; 2190 :     return op_code != OP_VSPACE;

	xor	eax, eax
	cmp	ecx, 20					; 00000014H
	pop	ebp
	setne	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN58@check_auto:

; 2193 :     }
; 2194 : 
; 2195 :   default:
; 2196 :   return FALSE;
; 2197 :   }
; 2198 : 
; 2199 : 
; 2200 : /* Handle the case when the next item is \d, \s, etc. */
; 2201 : 
; 2202 : switch(op_code)

	mov	eax, DWORD PTR _op_code$[esp+12]
	add	eax, -6					; fffffffaH
	cmp	eax, 22					; 00000016H
	ja	$LN74@check_auto
	movzx	eax, BYTE PTR $LN167@check_auto[eax]
	jmp	DWORD PTR $LN187@check_auto[eax*4]
$LN31@check_auto:

; 2203 :   {
; 2204 :   case OP_CHAR:
; 2205 :   case OP_CHARNC:
; 2206 : #ifdef SUPPORT_UTF8
; 2207 :   if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
; 2208 : #endif
; 2209 :   switch(-next)

	neg	ebp
	lea	eax, DWORD PTR [ebp-6]
	cmp	eax, 14					; 0000000eH
	ja	$LN74@check_auto
	movzx	ecx, BYTE PTR $LN168@check_auto[eax]
	jmp	DWORD PTR $LN188@check_auto[ecx*4]
$LN28@check_auto:

; 2210 :     {
; 2211 :     case ESC_d:
; 2212 :     return item > 127 || (cd->ctypes[item] & ctype_digit) == 0;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 127				; 0000007fH
	jg	$LN104@check_auto
	mov	edx, DWORD PTR [edi+12]
	test	BYTE PTR [eax+edx], 4
	jmp	$LN185@check_auto
$LN27@check_auto:

; 2213 : 
; 2214 :     case ESC_D:
; 2215 :     return item <= 127 && (cd->ctypes[item] & ctype_digit) != 0;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 127				; 0000007fH
	jg	$LN74@check_auto
	mov	ecx, DWORD PTR [edi+12]
	test	BYTE PTR [eax+ecx], 4
	je	$LN74@check_auto
	pop	esi
	pop	ebp
	mov	eax, 1
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN26@check_auto:

; 2216 : 
; 2217 :     case ESC_s:
; 2218 :     return item > 127 || (cd->ctypes[item] & ctype_space) == 0;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 127				; 0000007fH
	jg	$LN104@check_auto
	mov	edx, DWORD PTR [edi+12]
	test	BYTE PTR [eax+edx], 1
	jmp	$LN185@check_auto
$LN25@check_auto:

; 2219 : 
; 2220 :     case ESC_S:
; 2221 :     return item <= 127 && (cd->ctypes[item] & ctype_space) != 0;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 127				; 0000007fH
	jg	$LN74@check_auto
	mov	ecx, DWORD PTR [edi+12]
	test	BYTE PTR [eax+ecx], 1
	je	$LN74@check_auto
	pop	esi
	pop	ebp
	mov	eax, 1
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN24@check_auto:

; 2222 : 
; 2223 :     case ESC_w:
; 2224 :     return item > 127 || (cd->ctypes[item] & ctype_word) == 0;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 127				; 0000007fH
	jg	$LN104@check_auto
	mov	edx, DWORD PTR [edi+12]
	test	BYTE PTR [eax+edx], 16			; 00000010H
	jmp	$LN185@check_auto
$LN23@check_auto:

; 2225 : 
; 2226 :     case ESC_W:
; 2227 :     return item <= 127 && (cd->ctypes[item] & ctype_word) != 0;

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 127				; 0000007fH
	jg	$LN74@check_auto
	mov	ecx, DWORD PTR [edi+12]
	test	BYTE PTR [eax+ecx], 16			; 00000010H
	je	$LN74@check_auto
	pop	esi
	pop	ebp
	mov	eax, 1
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN22@check_auto:

; 2228 : 
; 2229 :     case ESC_h:
; 2230 :     case ESC_H:
; 2231 :     switch(item)

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 6158				; 0000180eH
	jg	SHORT $LN132@check_auto
	je	SHORT $LN19@check_auto
	cmp	eax, 160				; 000000a0H
	jg	SHORT $LN133@check_auto
	je	SHORT $LN19@check_auto
	cmp	eax, 9
	je	SHORT $LN19@check_auto
	cmp	eax, 32					; 00000020H
	jmp	SHORT $LN180@check_auto
$LN133@check_auto:
	cmp	eax, 5760				; 00001680H
	jmp	SHORT $LN180@check_auto
$LN132@check_auto:
	cmp	eax, 8287				; 0000205fH
	jg	SHORT $LN134@check_auto
	je	SHORT $LN19@check_auto
	cmp	eax, 8192				; 00002000H
	jl	SHORT $LN18@check_auto
	cmp	eax, 8202				; 0000200aH
	jle	SHORT $LN19@check_auto
	cmp	eax, 8239				; 0000202fH
	jmp	SHORT $LN180@check_auto
$LN134@check_auto:
	cmp	eax, 12288				; 00003000H
$LN180@check_auto:
	je	SHORT $LN19@check_auto
$LN18@check_auto:

; 2253 :       default:
; 2254 :       return -next == ESC_h;

	xor	eax, eax
	pop	esi
	cmp	ebp, 18					; 00000012H
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN19@check_auto:

; 2232 :       {
; 2233 :       case 0x09:
; 2234 :       case 0x20:
; 2235 :       case 0xa0:
; 2236 :       case 0x1680:
; 2237 :       case 0x180e:
; 2238 :       case 0x2000:
; 2239 :       case 0x2001:
; 2240 :       case 0x2002:
; 2241 :       case 0x2003:
; 2242 :       case 0x2004:
; 2243 :       case 0x2005:
; 2244 :       case 0x2006:
; 2245 :       case 0x2007:
; 2246 :       case 0x2008:
; 2247 :       case 0x2009:
; 2248 :       case 0x200A:
; 2249 :       case 0x202f:
; 2250 :       case 0x205f:
; 2251 :       case 0x3000:
; 2252 :       return -next != ESC_h;

	xor	eax, eax
	pop	esi
	cmp	ebp, 18					; 00000012H
	pop	ebp
	setne	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN20@check_auto:

; 2255 :       }
; 2256 : 
; 2257 :     case ESC_v:
; 2258 :     case ESC_V:
; 2259 :     switch(item)

	mov	eax, DWORD PTR _item$[esp+12]
	cmp	eax, 133				; 00000085H
	jg	SHORT $LN135@check_auto
	je	SHORT $LN14@check_auto
	cmp	eax, 10					; 0000000aH
	jl	SHORT $LN13@check_auto
	cmp	eax, 13					; 0000000dH
	jle	SHORT $LN14@check_auto
$LN13@check_auto:

; 2269 :       default:
; 2270 :       return -next == ESC_v;

	xor	eax, eax
	pop	esi
	cmp	ebp, 20					; 00000014H
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN135@check_auto:

; 2255 :       }
; 2256 : 
; 2257 :     case ESC_v:
; 2258 :     case ESC_V:
; 2259 :     switch(item)

	cmp	eax, 8232				; 00002028H
	jl	SHORT $LN13@check_auto
	cmp	eax, 8233				; 00002029H
	jg	SHORT $LN13@check_auto
$LN14@check_auto:

; 2260 :       {
; 2261 :       case 0x0a:
; 2262 :       case 0x0b:
; 2263 :       case 0x0c:
; 2264 :       case 0x0d:
; 2265 :       case 0x85:
; 2266 :       case 0x2028:
; 2267 :       case 0x2029:
; 2268 :       return -next != ESC_v;

	xor	eax, eax
	pop	esi
	cmp	ebp, 20					; 00000014H
	pop	ebp
	setne	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN29@check_auto:

; 2271 :       }
; 2272 : 
; 2273 :     default:
; 2274 :     return FALSE;
; 2275 :     }
; 2276 : 
; 2277 :   case OP_DIGIT:
; 2278 :   return next == -ESC_D || next == -ESC_s || next == -ESC_W ||
; 2279 :          next == -ESC_h || next == -ESC_v;

	cmp	ebp, -6					; fffffffaH
	je	$LN104@check_auto
	cmp	ebp, -9					; fffffff7H
	je	$LN104@check_auto
	cmp	ebp, -10				; fffffff6H
$LN182@check_auto:
	je	$LN104@check_auto
	cmp	ebp, -18				; ffffffeeH
	je	$LN104@check_auto
	cmp	ebp, -20				; ffffffecH
	jmp	SHORT $LN185@check_auto
$LN10@check_auto:

; 2280 : 
; 2281 :   case OP_NOT_DIGIT:
; 2282 :   return next == -ESC_d;

	xor	eax, eax
	pop	esi
	cmp	ebp, -7					; fffffff9H
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN9@check_auto:

; 2283 : 
; 2284 :   case OP_WHITESPACE:
; 2285 :   return next == -ESC_S || next == -ESC_d || next == -ESC_w;

	cmp	ebp, -8					; fffffff8H
	jmp	SHORT $LN184@check_auto
$LN7@check_auto:

; 2286 : 
; 2287 :   case OP_NOT_WHITESPACE:
; 2288 :   return next == -ESC_s || next == -ESC_h || next == -ESC_v;
; 2289 : 
; 2290 :   case OP_HSPACE:
; 2291 :   return next == -ESC_S || next == -ESC_H || next == -ESC_d || next == -ESC_w;

	cmp	ebp, -8					; fffffff8H
	je	$LN104@check_auto
	cmp	ebp, -17				; ffffffefH
$LN184@check_auto:
	je	$LN104@check_auto
	cmp	ebp, -7					; fffffff9H
	je	$LN104@check_auto
	cmp	ebp, -11				; fffffff5H
	jmp	SHORT $LN185@check_auto
$LN6@check_auto:

; 2292 : 
; 2293 :   case OP_NOT_HSPACE:
; 2294 :   return next == -ESC_h;

	xor	eax, eax
	pop	esi
	cmp	ebp, -18				; ffffffeeH
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN5@check_auto:

; 2295 : 
; 2296 :   /* Can't have \S in here because VT matches \S (Perl anomaly) */
; 2297 :   case OP_VSPACE:
; 2298 :   return next == -ESC_V || next == -ESC_d || next == -ESC_w;

	cmp	ebp, -19				; ffffffedH
	jmp	SHORT $LN184@check_auto
$LN4@check_auto:

; 2299 : 
; 2300 :   case OP_NOT_VSPACE:
; 2301 :   return next == -ESC_v;

	xor	eax, eax
	pop	esi
	cmp	ebp, -20				; ffffffecH
	pop	ebp
	sete	al
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
$LN3@check_auto:

; 2302 : 
; 2303 :   case OP_WORDCHAR:
; 2304 :   return next == -ESC_W || next == -ESC_s || next == -ESC_h || next == -ESC_v;

	cmp	ebp, -10				; fffffff6H
	je	$LN104@check_auto
$LN8@check_auto:
	cmp	ebp, -9					; fffffff7H
	jmp	SHORT $LN182@check_auto
$LN2@check_auto:

; 2305 : 
; 2306 :   case OP_NOT_WORDCHAR:
; 2307 :   return next == -ESC_w || next == -ESC_d;

	cmp	ebp, -11				; fffffff5H
	je	$LN104@check_auto
	cmp	ebp, -7					; fffffff9H
$LN185@check_auto:
	je	$LN104@check_auto
$LN74@check_auto:
	pop	esi
	pop	ebp

; 2045 :   }
; 2046 : 
; 2047 : else return FALSE;

	xor	eax, eax
	pop	ebx

; 2308 : 
; 2309 :   default:
; 2310 :   return FALSE;
; 2311 :   }
; 2312 : 
; 2313 : /* Control does not reach here */
; 2314 : }

	pop	ecx
	ret	0
	npad	3
$LN186@check_auto:
	DD	$LN49@check_auto
	DD	$LN50@check_auto
	DD	$LN47@check_auto
	DD	$LN48@check_auto
	DD	$LN45@check_auto
	DD	$LN46@check_auto
	DD	$LN44@check_auto
	DD	$LN42@check_auto
	DD	$LN57@check_auto
	DD	$LN56@check_auto
	DD	$LN54@check_auto
	DD	$LN74@check_auto
$LN166@check_auto:
	DB	0
	DB	1
	DB	2
	DB	3
	DB	4
	DB	5
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	6
	DB	6
	DB	7
	DB	7
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	8
	DB	9
	DB	10					; 0000000aH
$LN187@check_auto:
	DD	$LN10@check_auto
	DD	$LN29@check_auto
	DD	$LN8@check_auto
	DD	$LN9@check_auto
	DD	$LN2@check_auto
	DD	$LN3@check_auto
	DD	$LN6@check_auto
	DD	$LN7@check_auto
	DD	$LN4@check_auto
	DD	$LN5@check_auto
	DD	$LN31@check_auto
	DD	$LN74@check_auto
$LN167@check_auto:
	DB	0
	DB	1
	DB	2
	DB	3
	DB	4
	DB	5
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	6
	DB	7
	DB	8
	DB	9
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	10					; 0000000aH
	DB	10					; 0000000aH
	npad	1
$LN188@check_auto:
	DD	$LN27@check_auto
	DD	$LN28@check_auto
	DD	$LN25@check_auto
	DD	$LN26@check_auto
	DD	$LN23@check_auto
	DD	$LN24@check_auto
	DD	$LN22@check_auto
	DD	$LN20@check_auto
	DD	$LN74@check_auto
$LN168@check_auto:
	DB	0
	DB	1
	DB	2
	DB	3
	DB	4
	DB	5
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	6
	DB	6
	DB	7
	DB	7
_check_auto_possessive ENDP
_TEXT	ENDS
PUBLIC	??_C@_06ELOHELOA@DEFINE?$AA@			; `string'
PUBLIC	__real@41dfffffffc00000
PUBLIC	??_C@_03EFKCCELA@Q?2E?$AA@			; `string'
EXTRN	_memmove:PROC
EXTRN	__fltused:DWORD
EXTRN	_memcpy:PROC
;	COMDAT ??_C@_06ELOHELOA@DEFINE?$AA@
CONST	SEGMENT
??_C@_06ELOHELOA@DEFINE?$AA@ DB 'DEFINE', 00H		; `string'
CONST	ENDS
;	COMDAT __real@41dfffffffc00000
CONST	SEGMENT
__real@41dfffffffc00000 DQ 041dfffffffc00000r	; 2.14748e+009
CONST	ENDS
;	COMDAT ??_C@_03EFKCCELA@Q?2E?$AA@
CONST	SEGMENT
??_C@_03EFKCCELA@Q?2E?$AA@ DB 'Q\E', 00H		; `string'
; Function compile flags: /Ogtpy
CONST	ENDS
;	COMDAT _compile_branch
_TEXT	SEGMENT
_ptr$ = -200						; size = 4
_code$ = -196						; size = 4
_slot$6459 = -192					; size = 4
_recno$6014 = -192					; size = 4
_bralink$6334 = -192					; size = 4
_c$ = -192						; size = 4
tv2653 = -188						; size = 4
_unset$6455 = -188					; size = 4
_called$6596 = -188					; size = 4
_namelen$6456 = -188					; size = 4
_terminator$6019 = -188					; size = 4
_i$6331 = -188						; size = 4
_prop_type$6288 = -188					; size = 4
_class_lastchar$6012 = -188				; size = 4
_i$6453 = -184						; size = 4
_previous$ = -184					; size = 4
_name$6458 = -180					; size = 4
_len$6333 = -180					; size = 4
_prop_value$6289 = -180					; size = 4
_class_charcount$6011 = -180				; size = 4
_is_recurse$6009 = -176					; size = 4
_vn$6436 = -176						; size = 4
_skipbytes$6016 = -176					; size = 4
_this_hwm$6383 = -176					; size = 4
_this_hwm$6364 = -176					; size = 4
_delta$6352 = -176					; size = 4
_op_type$ = -176					; size = 4
_negate_class$6005 = -176				; size = 4
_is_quantifier$6008 = -176				; size = 4
_possessive_quantifier$6007 = -172			; size = 4
_should_flip_negation$6006 = -172			; size = 4
_bravalue$ = -172					; size = 4
_options$ = -168					; size = 4
_firstbyte$ = -164					; size = 4
_repeat_max$ = -160					; size = 4
_tempcode$ = -156					; size = 4
_repeat_min$ = -152					; size = 4
_reqbyte$ = -148					; size = 4
tv3622 = -144						; size = 4
_tempreqvary$ = -144					; size = 4
_set$6454 = -144					; size = 4
_refsign$6015 = -144					; size = 4
_name$6437 = -144					; size = 4
_ketoffset$6332 = -144					; size = 4
_inescq$ = -140						; size = 4
_local_negate$6101 = -136				; size = 4
_zeroreqbyte$ = -136					; size = 4
tv3346 = -132						; size = 4
tv3310 = -132						; size = 4
tv2889 = -132						; size = 4
_newoptions$6013 = -132					; size = 4
_oldptr$6095 = -132					; size = 4
_zerofirstbyte$ = -128					; size = 4
_length_prevgroup$ = -124				; size = 4
_save_hwm$ = -120					; size = 4
tv3297 = -113						; size = 1
_previous_callout$ = -112				; size = 4
_classbits$ = -108					; size = 32
_last_code$ = -76					; size = 4
_req_caseopt$ = -72					; size = 4
_reset_bracount$6010 = -68				; size = 4
_reqvary$ = -68						; size = 4
_tempptr$ = -64						; size = 4
_subreqbyte$6017 = -60					; size = 4
_groupsetfirstbyte$ = -56				; size = 4
_subfirstbyte$6018 = -52				; size = 4
_after_manual_callout$ = -48				; size = 4
_greedy_non_default$ = -44				; size = 4
_greedy_default$ = -40					; size = 4
_orig_code$ = -36					; size = 4
_pbits$6106 = -32					; size = 32
_optionsptr$ = 8					; size = 4
_codeptr$ = 12						; size = 4
_ptrptr$ = 16						; size = 4
_errorcodeptr$ = 20					; size = 4
_firstbyteptr$ = 24					; size = 4
_reqbyteptr$ = 28					; size = 4
_bcptr$ = 32						; size = 4
_cd$ = 36						; size = 4
_lengthptr$ = 40					; size = 4
_compile_branch PROC					; COMDAT

; 2348 : {

	sub	esp, 200				; 000000c8H

; 2349 : int repeat_type, op_type;
; 2350 : int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
; 2351 : int bravalue = 0;
; 2352 : int greedy_default, greedy_non_default;
; 2353 : int firstbyte, reqbyte;
; 2354 : int zeroreqbyte, zerofirstbyte;
; 2355 : int req_caseopt, reqvary, tempreqvary;
; 2356 : int options = *optionsptr;

	mov	eax, DWORD PTR _optionsptr$[esp+196]
	mov	eax, DWORD PTR [eax]

; 2357 : int after_manual_callout = 0;
; 2358 : int length_prevgroup = 0;
; 2359 : register int c;
; 2360 : register uschar *code = *codeptr;

	mov	edx, DWORD PTR _codeptr$[esp+196]
	mov	DWORD PTR _options$[esp+200], eax

; 2361 : uschar *last_code = code;
; 2362 : uschar *orig_code = code;
; 2363 : uschar *tempcode;
; 2364 : BOOL inescq = FALSE;
; 2365 : BOOL groupsetfirstbyte = FALSE;
; 2366 : const uschar *ptr = *ptrptr;
; 2367 : const uschar *tempptr;
; 2368 : uschar *previous = NULL;
; 2369 : uschar *previous_callout = NULL;
; 2370 : uschar *save_hwm = NULL;
; 2371 : uschar classbits[32];
; 2372 : 
; 2373 : #ifdef SUPPORT_UTF8
; 2374 : BOOL class_utf8;
; 2375 : BOOL utf8 = (options & PCRE_UTF8) != 0;
; 2376 : uschar *class_utf8data;
; 2377 : uschar *class_utf8data_base;
; 2378 : uschar utf8_char[6];
; 2379 : #else
; 2380 : BOOL utf8 = FALSE;
; 2381 : uschar *utf8_char = NULL;
; 2382 : #endif
; 2383 : 
; 2384 : #ifdef DEBUG
; 2385 : if (lengthptr != NULL) DPRINTF((">> start branch\n"));
; 2386 : #endif
; 2387 : 
; 2388 : /* Set up the default and non-default settings for greediness */
; 2389 : 
; 2390 : greedy_default = ((options & PCRE_UNGREEDY) != 0);

	shr	eax, 9
	and	eax, 1
	mov	DWORD PTR _greedy_default$[esp+200], eax

; 2391 : greedy_non_default = greedy_default ^ 1;

	xor	eax, 1
	push	ebx
	mov	DWORD PTR _greedy_non_default$[esp+204], eax

; 2392 : 
; 2393 : /* Initialize no first byte, no required byte. REQ_UNSET means "no char
; 2394 : matching encountered yet". It gets changed to REQ_NONE if we hit something that
; 2395 : matches a non-fixed char first char; reqbyte just remains unset if we never
; 2396 : find one.
; 2397 : 
; 2398 : When we hit a repeat whose minimum is zero, we may have to adjust these values
; 2399 : to take the zero repeat into account. This is implemented by setting them to
; 2400 : zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
; 2401 : item types that can be repeated set these backoff variables appropriately. */
; 2402 : 
; 2403 : firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;

	mov	eax, -2					; fffffffeH
	push	ebp
	mov	ebp, DWORD PTR [edx]
	xor	ecx, ecx
	push	esi
	mov	esi, DWORD PTR _ptrptr$[esp+208]
	mov	DWORD PTR _zeroreqbyte$[esp+212], eax
	mov	DWORD PTR _zerofirstbyte$[esp+212], eax
	mov	DWORD PTR _reqbyte$[esp+212], eax
	mov	DWORD PTR _firstbyte$[esp+212], eax

; 2404 : 
; 2405 : /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
; 2406 : according to the current setting of the caseless flag. REQ_CASELESS is a bit
; 2407 : value > 255. It is added into the firstbyte or reqbyte variables to record the
; 2408 : case status of the value. This is used only for ASCII characters. */
; 2409 : 
; 2410 : req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;

	mov	eax, DWORD PTR _options$[esp+212]
	push	edi
	mov	edi, DWORD PTR [esi]
	xor	esi, esi
	and	eax, 1
	mov	edx, ebp
	mov	ebx, ebp
	shl	eax, 8
	mov	DWORD PTR _repeat_min$[esp+216], ecx
	mov	DWORD PTR _repeat_max$[esp+216], ecx
	mov	DWORD PTR _after_manual_callout$[esp+216], ecx
	mov	DWORD PTR _length_prevgroup$[esp+216], ecx
	mov	DWORD PTR _code$[esp+216], ebp
	mov	DWORD PTR _last_code$[esp+216], edx
	mov	DWORD PTR _orig_code$[esp+216], ebx
	mov	DWORD PTR _inescq$[esp+216], ecx
	mov	DWORD PTR _groupsetfirstbyte$[esp+216], ecx
	mov	DWORD PTR _previous$[esp+216], ecx
	mov	DWORD PTR _previous_callout$[esp+216], esi
	mov	DWORD PTR _save_hwm$[esp+216], ecx
	mov	DWORD PTR _req_caseopt$[esp+216], eax
$LN883@compile_br:

; 2415 :   {
; 2416 :   BOOL negate_class;
; 2417 :   BOOL should_flip_negation;
; 2418 :   BOOL possessive_quantifier;
; 2419 :   BOOL is_quantifier;
; 2420 :   BOOL is_recurse;
; 2421 :   BOOL reset_bracount;
; 2422 :   int class_charcount;
; 2423 :   int class_lastchar;
; 2424 :   int newoptions;
; 2425 :   int recno;
; 2426 :   int refsign;
; 2427 :   int skipbytes;
; 2428 :   int subreqbyte;
; 2429 :   int subfirstbyte;
; 2430 :   int terminator;
; 2431 :   int mclength;
; 2432 :   uschar mcbuffer[8];
; 2433 : 
; 2434 :   /* Get next byte in the pattern */
; 2435 : 
; 2436 :   c = *ptr;
; 2437 : 
; 2438 :   /* If we are in the pre-compile phase, accumulate the length used for the
; 2439 :   previous cycle of this loop. */
; 2440 : 
; 2441 :   if (lengthptr != NULL)

	cmp	DWORD PTR _lengthptr$[esp+212], ecx
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	eax, BYTE PTR [edi]
	mov	DWORD PTR _c$[esp+216], eax
	je	$LN535@compile_br

; 2442 :     {
; 2443 : #ifdef DEBUG
; 2444 :     if (code > cd->hwm) cd->hwm = code;                 /* High water info */
; 2445 : #endif
; 2446 :     if (code > cd->start_workspace + COMPILE_WORK_SIZE) /* Check for overrun */

	mov	ecx, DWORD PTR _cd$[esp+212]
	mov	eax, DWORD PTR [ecx+16]
	add	eax, 4096				; 00001000H
	cmp	ebp, eax
	ja	$LN677@compile_br

; 2449 :       goto FAILED;
; 2450 :       }
; 2451 : 
; 2452 :     /* There is at least one situation where code goes backwards: this is the
; 2453 :     case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,
; 2454 :     the class is simply eliminated. However, it is created first, so we have to
; 2455 :     allow memory for it. Therefore, don't ever reduce the length at this point.
; 2456 :     */
; 2457 : 
; 2458 :     if (code < last_code) code = last_code;

	cmp	ebp, edx
	jae	SHORT $LN533@compile_br
	mov	DWORD PTR _code$[esp+216], edx
	mov	ebp, edx
$LN533@compile_br:

; 2459 : 
; 2460 :     /* Paranoid check for integer overflow */
; 2461 : 
; 2462 :     if (OFLOW_MAX - *lengthptr < code - last_code)

	mov	ecx, DWORD PTR _lengthptr$[esp+212]
	mov	eax, DWORD PTR [ecx]
	mov	ecx, ebp
	sub	ecx, edx
	mov	edx, 2147483627				; 7fffffebH
	sub	edx, eax
	cmp	edx, ecx
	jl	$LN678@compile_br

; 2465 :       goto FAILED;
; 2466 :       }
; 2467 : 
; 2468 :     *lengthptr += code - last_code;

	sub	eax, DWORD PTR _last_code$[esp+216]
	mov	ecx, DWORD PTR _lengthptr$[esp+212]
	add	eax, ebp
	mov	DWORD PTR [ecx], eax

; 2469 :     DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
; 2470 : 
; 2471 :     /* If "previous" is set and it is not at the start of the work space, move
; 2472 :     it back to there, in order to avoid filling up the work space. Otherwise,
; 2473 :     if "previous" is NULL, reset the current code pointer to the start. */
; 2474 : 
; 2475 :     if (previous != NULL)

	mov	eax, DWORD PTR _previous$[esp+216]
	xor	ecx, ecx
	cmp	eax, ecx
	je	SHORT $LN531@compile_br

; 2476 :       {
; 2477 :       if (previous > orig_code)

	cmp	eax, ebx
	jbe	SHORT $LN850@compile_br

; 2478 :         {
; 2479 :         memmove(orig_code, previous, code - previous);

	mov	edi, eax
	mov	edx, ebp
	sub	edx, edi
	push	edx
	push	edi
	push	ebx
	call	_memmove

; 2480 :         code -= previous - orig_code;

	mov	eax, ebx
	sub	eax, edi

; 2481 :         previous = orig_code;
; 2482 :         }

	mov	edi, DWORD PTR _ptr$[esp+228]
	add	ebp, eax
	add	esp, 12					; 0000000cH
	mov	DWORD PTR _code$[esp+216], ebp
	mov	DWORD PTR _previous$[esp+216], ebx
	xor	ecx, ecx

; 2485 : 
; 2486 :     /* Remember where this code item starts so we can pick up the length
; 2487 :     next time round. */
; 2488 : 
; 2489 :     last_code = code;

	mov	DWORD PTR _last_code$[esp+216], ebp
	jmp	SHORT $LN527@compile_br
$LN531@compile_br:

; 2483 :       }
; 2484 :     else code = orig_code;

	mov	DWORD PTR _code$[esp+216], ebx
	mov	ebp, ebx
$LN850@compile_br:

; 2485 : 
; 2486 :     /* Remember where this code item starts so we can pick up the length
; 2487 :     next time round. */
; 2488 : 
; 2489 :     last_code = code;

	mov	DWORD PTR _last_code$[esp+216], ebp
	jmp	SHORT $LN527@compile_br
$LN535@compile_br:

; 2490 :     }
; 2491 : 
; 2492 :   /* In the real compile phase, just check the workspace used by the forward
; 2493 :   reference list. */
; 2494 : 
; 2495 :   else if (cd->hwm > cd->start_workspace + COMPILE_WORK_SIZE)

	mov	eax, DWORD PTR _cd$[esp+212]
	mov	edx, DWORD PTR [eax+16]
	add	edx, 4096				; 00001000H
	cmp	DWORD PTR [eax+32], edx
	ja	$LN679@compile_br
$LN527@compile_br:

; 2498 :     goto FAILED;
; 2499 :     }
; 2500 : 
; 2501 :   /* If in \Q...\E, check for the end; if not, we have a literal */
; 2502 : 
; 2503 :   if (inescq && c != 0)

	cmp	DWORD PTR _inescq$[esp+216], ecx
	mov	edx, DWORD PTR _c$[esp+216]
	je	$LN524@compile_br
	cmp	edx, ecx
	je	$LN524@compile_br

; 2504 :     {
; 2505 :     if (c == '\\' && ptr[1] == 'E')

	cmp	edx, 92					; 0000005cH
	jne	SHORT $LN525@compile_br
	cmp	BYTE PTR [edi+1], 69			; 00000045H
	jne	SHORT $LN525@compile_br
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1

; 2506 :       {
; 2507 :       inescq = FALSE;

	mov	DWORD PTR _inescq$[esp+216], ecx
	add	edi, 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN525@compile_br:

; 2508 :       ptr++;
; 2509 :       continue;
; 2510 :       }
; 2511 :     else
; 2512 :       {
; 2513 :       if (previous_callout != NULL)

	cmp	esi, ecx
	je	SHORT $LN857@compile_br

; 2514 :         {
; 2515 :         if (lengthptr == NULL)  /* Don't attempt in pre-compile phase */

	cmp	DWORD PTR _lengthptr$[esp+212], ecx
	jne	SHORT $LN856@compile_br

; 2516 :           complete_callout(previous_callout, ptr, cd);

	xor	ebx, ebx
	mov	bh, BYTE PTR [esi+2]
	mov	eax, edi
	mov	edi, DWORD PTR _cd$[esp+212]
	mov	bl, BYTE PTR [esi+3]
	sub	eax, ebx
	sub	eax, DWORD PTR [edi+24]
	mov	ebx, eax
	sar	ebx, 8
	mov	BYTE PTR [esi+4], bl
	mov	BYTE PTR [esi+5], al
	mov	edi, DWORD PTR _ptr$[esp+216]
$LN856@compile_br:

; 2517 :         previous_callout = NULL;

	mov	DWORD PTR _previous_callout$[esp+216], ecx
$LN857@compile_br:

; 2518 :         }
; 2519 :       if ((options & PCRE_AUTO_CALLOUT) != 0)

	test	DWORD PTR _options$[esp+216], 16384	; 00004000H
	je	SHORT $NORMAL_CHAR$6043

; 2520 :         {
; 2521 :         previous_callout = code;
; 2522 :         code = auto_callout(code, ptr, cd);

	mov	esi, DWORD PTR _cd$[esp+212]
	mov	BYTE PTR [ebp], 82			; 00000052H
	mov	BYTE PTR [ebp+1], 255			; 000000ffH
	mov	DWORD PTR _previous_callout$[esp+216], ebp
	mov	eax, edi
	add	ebp, 1
	mov	ecx, eax
	sub	ecx, DWORD PTR [esi+24]
	add	ebp, 1
	sar	ecx, 8
	mov	BYTE PTR [ebp], cl
	sub	al, BYTE PTR [esi+24]
	mov	BYTE PTR [ebp+2], 0
	mov	BYTE PTR [ebp+1], al
	mov	BYTE PTR [ebp+3], 0
	add	ebp, 4
	mov	DWORD PTR _code$[esp+216], ebp
$NORMAL_CHAR$6043:

; 5154 :       }
; 5155 : 
; 5156 :     /* We have a data character whose value is in c. In UTF-8 mode it may have
; 5157 :     a value > 127. We set its representation in the length/buffer, and then
; 5158 :     handle it as a data character. */
; 5159 : 
; 5160 : #ifdef SUPPORT_UTF8
; 5161 :     if (utf8 && c > 127)
; 5162 :       mclength = _pcre_ord2utf8(c, mcbuffer);
; 5163 :     else
; 5164 : #endif
; 5165 : 
; 5166 :      {
; 5167 :      mcbuffer[0] = c;
; 5168 :      mclength = 1;
; 5169 :      }
; 5170 :     goto ONE_CHAR;
; 5171 : 
; 5172 : 
; 5173 :     /* ===================================================================*/
; 5174 :     /* Handle a literal character. It is guaranteed not to be whitespace or #
; 5175 :     when the extended flag is set. If we are in UTF-8 mode, it may be a
; 5176 :     multi-byte literal character. */
; 5177 : 
; 5178 :     default:
; 5179 :     NORMAL_CHAR:
; 5180 :     mclength = 1;
; 5181 :     mcbuffer[0] = c;

	mov	al, dl
$ONE_CHAR$6253:

; 5182 : 
; 5183 : #ifdef SUPPORT_UTF8
; 5184 :     if (utf8 && c >= 0xc0)
; 5185 :       {
; 5186 :       while ((ptr[1] & 0xc0) == 0x80)
; 5187 :         mcbuffer[mclength++] = *(++ptr);
; 5188 :       }
; 5189 : #endif
; 5190 : 
; 5191 :     /* At this point we have the character's bytes in mcbuffer, and the length
; 5192 :     in mclength. When not in UTF-8 mode, the length is always 1. */
; 5193 : 
; 5194 :     ONE_CHAR:
; 5195 :     previous = code;
; 5196 :     *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARNC : OP_CHAR;

	test	BYTE PTR _options$[esp+216], 1
	mov	DWORD PTR _previous$[esp+216], ebp
	setne	cl
	add	cl, 27					; 0000001bH
	mov	BYTE PTR [ebp], cl
	add	ebp, 1

; 5197 :     for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];

	mov	BYTE PTR [ebp], al
	add	ebp, 1

; 5198 : 
; 5199 :     /* Remember if \r or \n were seen */
; 5200 : 
; 5201 :     if (mcbuffer[0] == '\r' || mcbuffer[0] == '\n')

	cmp	al, 13					; 0000000dH
	mov	DWORD PTR _code$[esp+216], ebp
	je	SHORT $LN9@compile_br
	cmp	al, 10					; 0000000aH
	jne	$LN843@compile_br
$LN9@compile_br:

; 5202 :       cd->external_flags |= PCRE_HASCRORLF;

	mov	ecx, DWORD PTR _cd$[esp+212]
	or	DWORD PTR [ecx+68], 32			; 00000020H
	jmp	$LN10@compile_br
$LN524@compile_br:

; 2523 :         }
; 2524 :       goto NORMAL_CHAR;
; 2525 :       }
; 2526 :     }
; 2527 : 
; 2528 :   /* Fill in length of a previous callout, except when the next thing is
; 2529 :   a quantifier. */
; 2530 : 
; 2531 :   is_quantifier = c == '*' || c == '+' || c == '?' ||
; 2532 :     (c == '{' && is_counted_repeat(ptr+1));

	cmp	edx, 42					; 0000002aH
	je	SHORT $LN541@compile_br
	cmp	edx, 43					; 0000002bH
	je	SHORT $LN541@compile_br
	cmp	edx, 63					; 0000003fH
	je	SHORT $LN541@compile_br
	cmp	edx, 123				; 0000007bH
	jne	SHORT $LN542@compile_br
	lea	eax, DWORD PTR [edi+1]
	call	_is_counted_repeat
	test	eax, eax
	mov	edx, DWORD PTR _c$[esp+216]
	jne	SHORT $LN541@compile_br
$LN542@compile_br:

; 2533 : 
; 2534 :   if (!is_quantifier && previous_callout != NULL &&
; 2535 :        after_manual_callout-- <= 0)

	test	esi, esi
	mov	DWORD PTR _is_quantifier$6008[esp+216], 0
	je	SHORT $LN853@compile_br
	mov	eax, DWORD PTR _after_manual_callout$[esp+216]
	mov	ecx, eax
	sub	eax, 1
	test	ecx, ecx
	mov	DWORD PTR _after_manual_callout$[esp+216], eax
	jg	SHORT $LN853@compile_br

; 2536 :     {
; 2537 :     if (lengthptr == NULL)      /* Don't attempt in pre-compile phase */

	cmp	DWORD PTR _lengthptr$[esp+212], 0

; 2538 :       complete_callout(previous_callout, ptr, cd);

	mov	ebx, DWORD PTR _cd$[esp+212]
	jne	SHORT $LN582@compile_br
	xor	ecx, ecx
	mov	ch, BYTE PTR [esi+2]
	mov	eax, edi
	mov	cl, BYTE PTR [esi+3]
	sub	eax, ecx
	sub	eax, DWORD PTR [ebx+24]
	mov	ecx, eax
	sar	ecx, 8
	mov	BYTE PTR [esi+4], cl
	mov	BYTE PTR [esi+5], al
	mov	edi, DWORD PTR _ptr$[esp+216]
$LN582@compile_br:

; 2539 :     previous_callout = NULL;

	mov	DWORD PTR _previous_callout$[esp+216], 0
	jmp	SHORT $LN520@compile_br
$LN541@compile_br:

; 2523 :         }
; 2524 :       goto NORMAL_CHAR;
; 2525 :       }
; 2526 :     }
; 2527 : 
; 2528 :   /* Fill in length of a previous callout, except when the next thing is
; 2529 :   a quantifier. */
; 2530 : 
; 2531 :   is_quantifier = c == '*' || c == '+' || c == '?' ||
; 2532 :     (c == '{' && is_counted_repeat(ptr+1));

	mov	DWORD PTR _is_quantifier$6008[esp+216], 1
$LN853@compile_br:

; 2539 :     previous_callout = NULL;

	mov	ebx, DWORD PTR _cd$[esp+212]
$LN520@compile_br:

; 2540 :     }
; 2541 : 
; 2542 :   /* In extended mode, skip white space and comments */
; 2543 : 
; 2544 :   if ((options & PCRE_EXTENDED) != 0)

	test	BYTE PTR _options$[esp+216], 8
	je	$LN839@compile_br

; 2545 :     {
; 2546 :     if ((cd->ctypes[c] & ctype_space) != 0) continue;

	mov	eax, DWORD PTR [ebx+12]
	test	BYTE PTR [edx+eax], 1
	jne	$LN537@compile_br

; 2547 :     if (c == '#')

	cmp	edx, 35					; 00000023H
	jne	SHORT $LN826@compile_br

; 2548 :       {
; 2549 :       while (*(++ptr) != 0)

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	test	al, al
	je	SHORT $LN772@compile_br
	mov	esi, DWORD PTR _cd$[esp+212]
$LL515@compile_br:

; 2550 :         {
; 2551 :         if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }

	mov	ecx, DWORD PTR [esi+80]
	test	ecx, ecx
	je	$LN549@compile_br
	mov	eax, DWORD PTR [esi+28]
	cmp	edi, eax
	jae	$LN545@compile_br
	push	0
	lea	edx, DWORD PTR [esi+84]
	push	edx
	push	eax
	push	ecx
	push	edi
	call	__pcre_is_newline
	mov	edi, DWORD PTR _ptr$[esp+236]
	add	esp, 20					; 00000014H
	test	eax, eax
	je	$LN545@compile_br
$LN662@compile_br:
	mov	ecx, DWORD PTR [esi+84]
	lea	edi, DWORD PTR [edi+ecx-1]
	mov	DWORD PTR _ptr$[esp+216], edi

; 2552 :         }
; 2553 :       if (*ptr != 0) continue;

	cmp	BYTE PTR [edi], 0
	jne	$LN537@compile_br
$LN772@compile_br:

; 2554 : 
; 2555 :       /* Else fall through to handle end of string */
; 2556 :       c = 0;

	mov	DWORD PTR _c$[esp+216], 0
	mov	edx, DWORD PTR _c$[esp+216]
$LN826@compile_br:
	mov	ebx, DWORD PTR _cd$[esp+212]
$LN839@compile_br:

; 2557 :       }
; 2558 :     }
; 2559 : 
; 2560 :   /* No auto callout for quantifiers. */
; 2561 : 
; 2562 :   if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)

	test	DWORD PTR _options$[esp+216], 16384	; 00004000H
	je	SHORT $LN860@compile_br
	cmp	DWORD PTR _is_quantifier$6008[esp+216], 0
	jne	SHORT $LN860@compile_br

; 2563 :     {
; 2564 :     previous_callout = code;
; 2565 :     code = auto_callout(code, ptr, cd);

	mov	BYTE PTR [ebp], 82			; 00000052H
	mov	BYTE PTR [ebp+1], 255			; 000000ffH
	mov	DWORD PTR _previous_callout$[esp+216], ebp
	mov	eax, edi
	add	ebp, 1
	mov	ecx, eax
	sub	ecx, DWORD PTR [ebx+24]
	add	ebp, 1
	sar	ecx, 8
	mov	BYTE PTR [ebp], cl
	sub	al, BYTE PTR [ebx+24]
	mov	BYTE PTR [ebp+2], 0
	mov	BYTE PTR [ebp+1], al
	mov	BYTE PTR [ebp+3], 0
	mov	edi, DWORD PTR _ptr$[esp+216]
	add	ebp, 4
	mov	DWORD PTR _code$[esp+216], ebp
$LN860@compile_br:

; 2566 :     }
; 2567 : 
; 2568 :   switch(c)

	cmp	edx, 124				; 0000007cH
	ja	$NORMAL_CHAR$6043
	movzx	eax, BYTE PTR $LN767@compile_br[edx]
	jmp	DWORD PTR $LN886@compile_br[eax*4]
$LN549@compile_br:

; 2550 :         {
; 2551 :         if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }

	mov	ecx, DWORD PTR [esi+84]
	mov	edx, DWORD PTR [esi+28]
	sub	edx, ecx
	cmp	edi, edx
	ja	SHORT $LN545@compile_br
	cmp	al, BYTE PTR [esi+88]
	jne	SHORT $LN545@compile_br
	cmp	ecx, 1
	je	$LN662@compile_br
	mov	al, BYTE PTR [edi+1]
	cmp	al, BYTE PTR [esi+89]
	je	$LN662@compile_br
$LN545@compile_br:

; 2548 :       {
; 2549 :       while (*(++ptr) != 0)

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	test	al, al
	jne	$LL515@compile_br
	jmp	$LN772@compile_br
$LN505@compile_br:

; 2589 : 
; 2590 : 
; 2591 :     /* ===================================================================*/
; 2592 :     /* Handle single-character metacharacters. In multiline mode, ^ disables
; 2593 :     the setting of any following char as a first character. */
; 2594 : 
; 2595 :     case '^':
; 2596 :     if ((options & PCRE_MULTILINE) != 0)

	test	BYTE PTR _options$[esp+216], 2
	je	SHORT $LN503@compile_br

; 2597 :       {
; 2598 :       if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;

	cmp	DWORD PTR _firstbyte$[esp+216], -2	; fffffffeH
	jne	SHORT $LN503@compile_br
	mov	DWORD PTR _firstbyte$[esp+216], -1
$LN503@compile_br:

; 2599 :       }
; 2600 :     previous = NULL;

	mov	DWORD PTR _previous$[esp+216], 0

; 2601 :     *code++ = OP_CIRC;

	mov	BYTE PTR [ebp], 25			; 00000019H
$LN882@compile_br:

; 2606 :     *code++ = OP_DOLL;

	add	ebp, 1
$LN884@compile_br:
	mov	DWORD PTR _code$[esp+216], ebp
$LN787@compile_br:

; 5117 :         }
; 5118 : 
; 5119 :       /* So are Unicode property matches, if supported. */
; 5120 : 
; 5121 : #ifdef SUPPORT_UCP
; 5122 :       else if (-c == ESC_P || -c == ESC_p)
; 5123 :         {
; 5124 :         BOOL negated;
; 5125 :         int pdata;
; 5126 :         int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
; 5127 :         if (ptype < 0) goto FAILED;
; 5128 :         previous = code;
; 5129 :         *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
; 5130 :         *code++ = ptype;
; 5131 :         *code++ = pdata;
; 5132 :         }
; 5133 : #else
; 5134 : 
; 5135 :       /* If Unicode properties are not supported, \X, \P, and \p are not
; 5136 :       allowed. */
; 5137 : 
; 5138 :       else if (-c == ESC_X || -c == ESC_P || -c == ESC_p)

	mov	edi, DWORD PTR _ptr$[esp+216]
$LN537@compile_br:

; 2411 : 
; 2412 : /* Switch on next character until the end of the branch */
; 2413 : 
; 2414 : for (;; ptr++)

	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN502@compile_br:

; 2602 :     break;
; 2603 : 
; 2604 :     case '$':
; 2605 :     previous = NULL;

	mov	DWORD PTR _previous$[esp+216], 0

; 2606 :     *code++ = OP_DOLL;

	mov	BYTE PTR [ebp], 26			; 0000001aH

; 2607 :     break;

	jmp	SHORT $LN882@compile_br
$LN501@compile_br:

; 2608 : 
; 2609 :     /* There can never be a first char if '.' is first, whatever happens about
; 2610 :     repeats. The value of reqbyte doesn't change either. */
; 2611 : 
; 2612 :     case '.':
; 2613 :     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;

	mov	eax, DWORD PTR _firstbyte$[esp+216]
	cmp	eax, -2					; fffffffeH
	jne	SHORT $LN500@compile_br
	or	eax, -1
	mov	DWORD PTR _firstbyte$[esp+216], eax
$LN500@compile_br:

; 2614 :     zerofirstbyte = firstbyte;
; 2615 :     zeroreqbyte = reqbyte;

	mov	ecx, DWORD PTR _reqbyte$[esp+216]
	mov	DWORD PTR _zerofirstbyte$[esp+216], eax
	mov	DWORD PTR _zeroreqbyte$[esp+216], ecx

; 2616 :     previous = code;

	mov	DWORD PTR _previous$[esp+216], ebp

; 2617 :     *code++ = OP_ANY;

	mov	BYTE PTR [ebp], 12			; 0000000cH

; 2618 :     break;

	jmp	SHORT $LN882@compile_br
$LN499@compile_br:

; 2619 : 
; 2620 : 
; 2621 :     /* ===================================================================*/
; 2622 :     /* Character classes. If the included characters are all < 256, we build a
; 2623 :     32-byte bitmap of the permitted characters, except in the special case
; 2624 :     where there is only one such character. For negated classes, we build the
; 2625 :     map as usual, then invert it at the end. However, we use a different opcode
; 2626 :     so that data characters > 255 can be handled correctly.
; 2627 : 
; 2628 :     If the class contains characters outside the 0-255 range, a different
; 2629 :     opcode is compiled. It may optionally have a bit map for characters < 256,
; 2630 :     but those above are are explicitly listed afterwards. A flag byte tells
; 2631 :     whether the bitmap is present, and whether this is a negated class or not.
; 2632 :     */
; 2633 : 
; 2634 :     case '[':
; 2635 :     previous = code;
; 2636 : 
; 2637 :     /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
; 2638 :     they are encountered at the top level, so we'll do that too. */
; 2639 : 
; 2640 :     if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
; 2641 :         check_posix_syntax(ptr, &tempptr))

	mov	al, BYTE PTR [edi+1]
	cmp	al, 58					; 0000003aH
	mov	DWORD PTR _previous$[esp+216], ebp
	je	SHORT $LN793@compile_br
	cmp	al, 46					; 0000002eH
	je	SHORT $LN793@compile_br
	cmp	al, 61					; 0000003dH
	jne	SHORT $LN498@compile_br
$LN793@compile_br:
	lea	edx, DWORD PTR _tempptr$[esp+216]
	push	edx
	mov	eax, edi
	call	_check_posix_syntax
	mov	edi, DWORD PTR _ptr$[esp+220]
	add	esp, 4
	test	eax, eax
	jne	$LN680@compile_br
$LN498@compile_br:

; 2644 :       goto FAILED;
; 2645 :       }
; 2646 : 
; 2647 :     /* If the first character is '^', set the negation flag and skip it. Also,
; 2648 :     if the first few characters (either before or after ^) are \Q\E or \E we
; 2649 :     skip them too. This makes for compatibility with Perl. */
; 2650 : 
; 2651 :     negate_class = FALSE;

	xor	ebx, ebx
$LN865@compile_br:
	mov	DWORD PTR _negate_class$6005[esp+216], ebx
	npad	5
$LL496@compile_br:

; 2652 :     for (;;)
; 2653 :       {
; 2654 :       c = *(++ptr);

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	esi, BYTE PTR [edi]

; 2655 :       if (c == '\\')

	cmp	esi, 92					; 0000005cH
	jne	SHORT $LN494@compile_br

; 2656 :         {
; 2657 :         if (ptr[1] == 'E') ptr++;

	add	edi, 1
	cmp	BYTE PTR [edi], 69			; 00000045H
	je	SHORT $LL496@compile_br

; 2658 :           else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;

	push	3
	push	OFFSET ??_C@_03EFKCCELA@Q?2E?$AA@
	push	edi
	call	_strncmp
	mov	edi, DWORD PTR _ptr$[esp+228]
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN795@compile_br
	add	edi, 3

; 2659 :             else break;
; 2660 :         }
; 2661 :       else if (!negate_class && c == '^')

	jmp	SHORT $LL496@compile_br
$LN494@compile_br:
	test	ebx, ebx
	jne	SHORT $LN795@compile_br
	cmp	esi, 94					; 0000005eH
	jne	SHORT $LN795@compile_br

; 2662 :         negate_class = TRUE;

	lea	ebx, DWORD PTR [esi-93]

; 2663 :       else break;
; 2664 :       }

	jmp	SHORT $LN865@compile_br
$LN795@compile_br:

; 2665 : 
; 2666 :     /* If a class contains a negative special such as \S, we need to flip the
; 2667 :     negation flag at the end, so that support for characters > 255 works
; 2668 :     correctly (they are all included in the class). */
; 2669 : 
; 2670 :     should_flip_negation = FALSE;

	xor	eax, eax

; 2671 : 
; 2672 :     /* Keep a count of chars with values < 256 so that we can optimize the case
; 2673 :     of just a single character (as long as it's < 256). However, For higher
; 2674 :     valued UTF-8 characters, we don't yet do any optimization. */
; 2675 : 
; 2676 :     class_charcount = 0;
; 2677 :     class_lastchar = -1;
; 2678 : 
; 2679 :     /* Initialize the 32-char bit map to all zeros. We build the map in a
; 2680 :     temporary bit of memory, in case the class contains only 1 character (less
; 2681 :     than 256), because in that case the compiled code doesn't use the bit map.
; 2682 :     */
; 2683 : 
; 2684 :     memset(classbits, 0, 32 * sizeof(uschar));
; 2685 : 
; 2686 : #ifdef SUPPORT_UTF8
; 2687 :     class_utf8 = FALSE;                       /* No chars >= 256 */
; 2688 :     class_utf8data = code + LINK_SIZE + 2;    /* For UTF-8 items */
; 2689 :     class_utf8data_base = class_utf8data;     /* For resetting in pass 1 */
; 2690 : #endif
; 2691 : 
; 2692 :     /* Process characters until ] is reached. By writing this as a "do" it
; 2693 :     means that an initial ] is taken as a data character. At the start of the
; 2694 :     loop, c contains the first byte of the character. */
; 2695 : 
; 2696 :     if (c != 0) do

	cmp	esi, eax
	mov	DWORD PTR _should_flip_negation$6006[esp+216], eax
	mov	DWORD PTR _class_charcount$6011[esp+216], eax
	mov	DWORD PTR _class_lastchar$6012[esp+216], -1
	mov	DWORD PTR _classbits$[esp+216], eax
	mov	DWORD PTR _classbits$[esp+220], eax
	mov	DWORD PTR _classbits$[esp+224], eax
	mov	DWORD PTR _classbits$[esp+228], eax
	mov	DWORD PTR _classbits$[esp+232], eax
	mov	DWORD PTR _classbits$[esp+236], eax
	mov	DWORD PTR _classbits$[esp+240], eax
	mov	DWORD PTR _classbits$[esp+244], eax
	je	$LN681@compile_br
$LL485@compile_br:

; 2697 :       {
; 2698 :       const uschar *oldptr;
; 2699 : 
; 2700 : #ifdef SUPPORT_UTF8
; 2701 :       if (utf8 && c > 127)
; 2702 :         {                           /* Braces are required because the */
; 2703 :         GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
; 2704 :         }
; 2705 : 
; 2706 :       /* In the pre-compile phase, accumulate the length of any UTF-8 extra
; 2707 :       data and reset the pointer. This is so that very large classes that
; 2708 :       contain a zillion UTF-8 characters no longer overwrite the work space
; 2709 :       (which is on the stack). */
; 2710 : 
; 2711 :       if (lengthptr != NULL)
; 2712 :         {
; 2713 :         *lengthptr += class_utf8data - class_utf8data_base;
; 2714 :         class_utf8data = class_utf8data_base;
; 2715 :         }
; 2716 : 
; 2717 : #endif
; 2718 : 
; 2719 :       /* Inside \Q...\E everything is literal except \E */
; 2720 : 
; 2721 :       if (inescq)

	xor	ebx, ebx
	cmp	DWORD PTR _inescq$[esp+216], ebx
	je	SHORT $LN482@compile_br

; 2722 :         {
; 2723 :         if (c == '\\' && ptr[1] == 'E')     /* If we are at \E */

	cmp	esi, 92					; 0000005cH
	jne	$CHECK_RANGE$6098
	cmp	BYTE PTR [edi+1], 69			; 00000045H
	jne	$CHECK_RANGE$6098

; 2724 :           {
; 2725 :           inescq = FALSE;                   /* Reset literal state */

	mov	DWORD PTR _inescq$[esp+216], ebx
	add	edi, 1

; 2726 :           ptr++;                            /* Skip the 'E' */
; 2727 :           continue;                         /* Carry on with next */

	jmp	$LN484@compile_br
$LN482@compile_br:

; 2728 :           }
; 2729 :         goto CHECK_RANGE;                   /* Could be range if \E follows */
; 2730 :         }
; 2731 : 
; 2732 :       /* Handle POSIX class names. Perl allows a negation extension of the
; 2733 :       form [:^name:]. A square bracket that doesn't match the syntax is
; 2734 :       treated as a literal. We also recognize the POSIX constructions
; 2735 :       [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
; 2736 :       5.6 and 5.8 do. */
; 2737 : 
; 2738 :       if (c == '[' &&
; 2739 :           (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
; 2740 :           check_posix_syntax(ptr, &tempptr))

	cmp	esi, 91					; 0000005bH
	jne	$LN480@compile_br
	mov	al, BYTE PTR [edi+1]
	cmp	al, 58					; 0000003aH
	je	SHORT $LN479@compile_br
	cmp	al, 46					; 0000002eH
	je	SHORT $LN479@compile_br
	cmp	al, 61					; 0000003dH
	jne	$CHECK_RANGE$6098
$LN479@compile_br:
	lea	eax, DWORD PTR _tempptr$[esp+216]
	push	eax
	mov	eax, edi
	call	_check_posix_syntax
	add	esp, 4
	test	eax, eax
	je	$LN840@compile_br

; 2741 :         {
; 2742 :         BOOL local_negate = FALSE;
; 2743 :         int posix_class, taboffset, tabopt;
; 2744 :         register const uschar *cbits = cd->cbits;
; 2745 :         uschar pbits[32];
; 2746 : 
; 2747 :         if (ptr[1] != ':')

	mov	edi, DWORD PTR _ptr$[esp+216]
	cmp	BYTE PTR [edi+1], 58			; 0000003aH
	mov	ecx, DWORD PTR _cd$[esp+212]
	mov	ebp, DWORD PTR [ecx+8]
	mov	DWORD PTR _local_negate$6101[esp+216], ebx
	jne	$LN663@compile_br

; 2750 :           goto FAILED;
; 2751 :           }
; 2752 : 
; 2753 :         ptr += 2;

	add	edi, 2
	mov	DWORD PTR _ptr$[esp+216], edi

; 2754 :         if (*ptr == '^')

	cmp	BYTE PTR [edi], 94			; 0000005eH
	jne	SHORT $LN477@compile_br

; 2755 :           {
; 2756 :           local_negate = TRUE;

	mov	eax, 1

; 2757 :           should_flip_negation = TRUE;  /* Note negative special */
; 2758 :           ptr++;

	add	edi, eax
	mov	DWORD PTR _local_negate$6101[esp+216], eax
	mov	DWORD PTR _should_flip_negation$6006[esp+216], eax
	mov	DWORD PTR _ptr$[esp+216], edi
$LN477@compile_br:

; 2759 :           }
; 2760 : 
; 2761 :         posix_class = check_posix_name(ptr, tempptr - ptr);

	mov	ebx, DWORD PTR _tempptr$[esp+216]
	sub	ebx, edi
	push	edi
	call	_check_posix_name
	add	esp, 4

; 2762 :         if (posix_class < 0)

	test	eax, eax
	jl	$LN664@compile_br

; 2766 :           }
; 2767 : 
; 2768 :         /* If matching is caseless, upper and lower are converted to
; 2769 :         alpha. This relies on the fact that the class table starts with
; 2770 :         alpha, lower, upper as the first 3 entries. */
; 2771 : 
; 2772 :         if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)

	test	BYTE PTR _options$[esp+216], 1
	je	SHORT $LN797@compile_br
	cmp	eax, 2
	jg	SHORT $LN797@compile_br

; 2773 :           posix_class = 0;

	xor	eax, eax
$LN797@compile_br:

; 2774 : 
; 2775 :         /* We build the bit map for the POSIX class in a chunk of local store
; 2776 :         because we may be adding and subtracting from it, and we don't want to
; 2777 :         subtract bits that may be in the main map already. At the end we or the
; 2778 :         result into the bit map that is being built. */
; 2779 : 
; 2780 :         posix_class *= 3;

	lea	eax, DWORD PTR [eax+eax*2]

; 2781 : 
; 2782 :         /* Copy in the first table (always present) */
; 2783 : 
; 2784 :         memcpy(pbits, cbits + posix_class_maps[posix_class],
; 2785 :           32 * sizeof(uschar));

	mov	esi, DWORD PTR _posix_class_maps[eax*4]
	add	esi, ebp
	mov	ecx, 8
	lea	edi, DWORD PTR _pbits$6106[esp+216]
	rep movsd

; 2786 : 
; 2787 :         /* If there is a second table, add or remove it as required. */
; 2788 : 
; 2789 :         taboffset = posix_class_maps[posix_class + 1];

	mov	ecx, DWORD PTR _posix_class_maps[eax*4+4]

; 2790 :         tabopt = posix_class_maps[posix_class + 2];
; 2791 : 
; 2792 :         if (taboffset >= 0)

	test	ecx, ecx
	mov	esi, DWORD PTR _posix_class_maps[eax*4+8]
	jl	SHORT $LN466@compile_br

; 2793 :           {
; 2794 :           if (tabopt >= 0)
; 2795 :             for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];

	xor	eax, eax
	add	ecx, ebp
	test	esi, esi
	jl	SHORT $LL468@compile_br
	npad	7
$LL472@compile_br:
	mov	dl, BYTE PTR [ecx+eax]
	or	BYTE PTR _pbits$6106[esp+eax+216], dl
	add	eax, 1
	cmp	eax, 32					; 00000020H
	jl	SHORT $LL472@compile_br

; 2796 :           else

	jmp	SHORT $LN466@compile_br
$LL468@compile_br:

; 2797 :             for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];

	mov	dl, BYTE PTR [ecx+eax]
	not	dl
	and	BYTE PTR _pbits$6106[esp+eax+216], dl
	add	eax, 1
	cmp	eax, 32					; 00000020H
	jl	SHORT $LL468@compile_br
$LN466@compile_br:

; 2798 :           }
; 2799 : 
; 2800 :         /* Not see if we need to remove any special characters. An option
; 2801 :         value of 1 removes vertical space and 2 removes underscore. */
; 2802 : 
; 2803 :         if (tabopt < 0) tabopt = -tabopt;

	test	esi, esi
	jge	SHORT $LN465@compile_br
	neg	esi
$LN465@compile_br:

; 2804 :         if (tabopt == 1) pbits[1] &= ~0x3c;

	cmp	esi, 1
	jne	SHORT $LN464@compile_br
	and	BYTE PTR _pbits$6106[esp+217], 195	; 000000c3H
	jmp	SHORT $LN462@compile_br
$LN464@compile_br:

; 2805 :           else if (tabopt == 2) pbits[11] &= 0x7f;

	cmp	esi, 2
	jne	SHORT $LN462@compile_br
	and	BYTE PTR _pbits$6106[esp+227], 127	; 0000007fH
$LN462@compile_br:

; 2806 : 
; 2807 :         /* Add the POSIX table or its complement into the main table that is
; 2808 :         being built and we are done. */
; 2809 : 
; 2810 :         if (local_negate)
; 2811 :           for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];

	xor	eax, eax
	cmp	DWORD PTR _local_negate$6101[esp+216], eax
	je	SHORT $LL456@compile_br
$LL460@compile_br:
	mov	cl, BYTE PTR _pbits$6106[esp+eax+216]
	not	cl
	or	BYTE PTR _classbits$[esp+eax+216], cl
	add	eax, 1
	cmp	eax, 32					; 00000020H
	jl	SHORT $LL460@compile_br

; 2812 :         else

	jmp	SHORT $LN454@compile_br
	npad	7
$LL456@compile_br:

; 2813 :           for (c = 0; c < 32; c++) classbits[c] |= pbits[c];

	mov	dl, BYTE PTR _pbits$6106[esp+eax+216]
	or	BYTE PTR _classbits$[esp+eax+216], dl
	add	eax, 1
	cmp	eax, 32					; 00000020H
	jl	SHORT $LL456@compile_br
$LN454@compile_br:

; 2814 : 
; 2815 :         ptr = tempptr + 1;

	mov	edi, DWORD PTR _tempptr$[esp+216]

; 2816 :         class_charcount = 10;  /* Set > 1; assumes more than 1 per class */
; 2817 :         continue;    /* End of POSIX syntax handling */

	mov	ebp, DWORD PTR _code$[esp+216]
	add	edi, 1
	mov	DWORD PTR _class_charcount$6011[esp+216], 10 ; 0000000aH
	jmp	$LN484@compile_br
$LN480@compile_br:

; 2818 :         }
; 2819 : 
; 2820 :       /* Backslash may introduce a single character, or it may introduce one
; 2821 :       of the specials, which just set a flag. The sequence \b is a special
; 2822 :       case. Inside a class (and only there) it is treated as backspace.
; 2823 :       Elsewhere it marks a word boundary. Other escapes have preset maps ready
; 2824 :       to 'or' into the one we are building. We assume they have more than one
; 2825 :       character in them, so set class_charcount bigger than one. */
; 2826 : 
; 2827 :       if (c == '\\')

	cmp	esi, 92					; 0000005cH
	jne	SHORT $CHECK_RANGE$6098

; 2828 :         {
; 2829 :         c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);

	mov	eax, DWORD PTR _cd$[esp+212]
	mov	ecx, DWORD PTR [eax+48]
	mov	edi, DWORD PTR _errorcodeptr$[esp+212]
	mov	ebx, DWORD PTR _options$[esp+216]
	push	1
	push	ecx
	lea	edx, DWORD PTR _ptr$[esp+224]
	push	edi
	push	edx
	mov	eax, ebx
	call	_check_escape
	add	esp, 16					; 00000010H

; 2830 :         if (*errorcodeptr != 0) goto FAILED;

	cmp	DWORD PTR [edi], 0
	mov	esi, eax
	jne	$LN789@compile_br

; 2831 : 
; 2832 :         if (-c == ESC_b) c = '\b';       /* \b is backspace in a class */

	mov	ecx, esi
	neg	ecx
	cmp	ecx, 5
	jne	$LN451@compile_br
	lea	esi, DWORD PTR [ecx+3]
$LN840@compile_br:

; 3046 :             }
; 3047 : 
; 3048 :           class_charcount -= 2;  /* Undo the default count from above */
; 3049 :           c = *ptr;              /* Get the final character and fall through */

	mov	edi, DWORD PTR _ptr$[esp+216]
$CHECK_RANGE$6098:

; 3050 :           }
; 3051 : 
; 3052 :         /* Fall through if we have a single character (c >= 0). This may be
; 3053 :         greater than 256 in UTF-8 mode. */
; 3054 : 
; 3055 :         }   /* End of backslash handling */
; 3056 : 
; 3057 :       /* A single character may be followed by '-' to form a range. However,
; 3058 :       Perl does not permit ']' to be the end of the range. A '-' character
; 3059 :       at the end is treated as a literal. Perl ignores orphaned \E sequences
; 3060 :       entirely. The code for handling \Q and \E is messy. */
; 3061 : 
; 3062 :       CHECK_RANGE:
; 3063 :       while (ptr[1] == '\\' && ptr[2] == 'E')

	cmp	BYTE PTR [edi+1], 92			; 0000005cH
	mov	edx, DWORD PTR _inescq$[esp+216]
	jne	SHORT $LN385@compile_br
$LL386@compile_br:
	cmp	BYTE PTR [edi+2], 69			; 00000045H
	jne	SHORT $LN864@compile_br
	add	edi, 2

; 3064 :         {
; 3065 :         inescq = FALSE;

	xor	edx, edx

; 3066 :         ptr += 2;

	mov	DWORD PTR _ptr$[esp+216], edi
	cmp	BYTE PTR [edi+1], 92			; 0000005cH
	je	SHORT $LL386@compile_br
$LN864@compile_br:

; 3064 :         {
; 3065 :         inescq = FALSE;

	mov	DWORD PTR _inescq$[esp+216], edx
$LN385@compile_br:

; 3067 :         }
; 3068 : 
; 3069 :       oldptr = ptr;
; 3070 : 
; 3071 :       /* Remember \r or \n */
; 3072 : 
; 3073 :       if (c == '\r' || c == '\n') cd->external_flags |= PCRE_HASCRORLF;

	cmp	esi, 13					; 0000000dH
	mov	ecx, edi
	mov	DWORD PTR _oldptr$6095[esp+216], ecx
	je	SHORT $LN799@compile_br
	cmp	esi, 10					; 0000000aH
	jne	SHORT $LN800@compile_br
$LN799@compile_br:
	mov	eax, DWORD PTR _cd$[esp+212]
	or	DWORD PTR [eax+68], 32			; 00000020H
$LN800@compile_br:

; 3074 : 
; 3075 :       /* Check for range */
; 3076 : 
; 3077 :       if (!inescq && ptr[1] == '-')

	test	edx, edx
	jne	$LONE_SINGLE_CHARACTER$6226
	cmp	BYTE PTR [edi+1], 45			; 0000002dH
	jne	$LONE_SINGLE_CHARACTER$6226

; 3078 :         {
; 3079 :         int d;
; 3080 :         ptr += 2;

	add	edi, 2
	mov	DWORD PTR _ptr$[esp+216], edi

; 3081 :         while (*ptr == '\\' && ptr[1] == 'E') ptr += 2;

	cmp	BYTE PTR [edi], 92			; 0000005cH
	jne	$LN378@compile_br
	npad	6
$LL381@compile_br:
	cmp	BYTE PTR [edi+1], 69			; 00000045H
	jne	$LN636@compile_br
	add	edi, 2
	mov	DWORD PTR _ptr$[esp+216], edi
	cmp	BYTE PTR [edi], 92			; 0000005cH
	je	SHORT $LL381@compile_br

; 3082 : 
; 3083 :         /* If we hit \Q (not followed by \E) at this point, go into escaped
; 3084 :         mode. */
; 3085 : 
; 3086 :         while (*ptr == '\\' && ptr[1] == 'Q')

	jmp	$LN378@compile_br
$LN451@compile_br:

; 2833 :         else if (-c == ESC_X) c = 'X';   /* \X is literal X in a class */

	cmp	ecx, 21					; 00000015H
	jne	SHORT $LN449@compile_br
	lea	esi, DWORD PTR [ecx+67]
	jmp	$LN840@compile_br
$LN449@compile_br:

; 2834 :         else if (-c == ESC_R) c = 'R';   /* \R is literal R in a class */

	cmp	ecx, 16					; 00000010H
	jne	SHORT $LN447@compile_br
	lea	esi, DWORD PTR [ecx+66]
	jmp	$LN840@compile_br
$LN447@compile_br:

; 2835 :         else if (-c == ESC_Q)            /* Handle start of quoted string */

	cmp	ecx, 25					; 00000019H
	jne	SHORT $LN445@compile_br

; 2836 :           {
; 2837 :           if (ptr[1] == '\\' && ptr[2] == 'E')

	mov	edi, DWORD PTR _ptr$[esp+216]
	cmp	BYTE PTR [edi+1], 92			; 0000005cH
	jne	SHORT $LN444@compile_br
	cmp	BYTE PTR [edi+2], 69			; 00000045H
	jne	SHORT $LN444@compile_br
	add	edi, 2

; 2838 :             {
; 2839 :             ptr += 2; /* avoid empty string */

	jmp	SHORT $LN484@compile_br
$LN444@compile_br:

; 2840 :             }
; 2841 :           else inescq = TRUE;

	mov	DWORD PTR _inescq$[esp+216], 1

; 2842 :           continue;

	jmp	SHORT $LN484@compile_br
$LN445@compile_br:

; 2843 :           }
; 2844 :         else if (-c == ESC_E) continue;  /* Ignore orphan \E */

	cmp	ecx, 24					; 00000018H
	je	SHORT $LN776@compile_br

; 2845 : 
; 2846 :         if (c < 0)

	test	esi, esi
	jge	$LN840@compile_br

; 2847 :           {
; 2848 :           register const uschar *cbits = cd->cbits;

	mov	eax, DWORD PTR _cd$[esp+212]

; 2849 :           class_charcount += 2;     /* Greater than 1 is what matters */

	add	DWORD PTR _class_charcount$6011[esp+216], 2

; 2850 : 
; 2851 :           /* Save time by not doing this in the pre-compile phase. */
; 2852 : 
; 2853 :           if (lengthptr == NULL) switch (-c)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	mov	eax, DWORD PTR [eax+8]
	jne	$LN439@compile_br
	lea	edx, DWORD PTR [ecx-6]
	cmp	edx, 5
	ja	$LN410@compile_br
	jmp	DWORD PTR $LN887@compile_br[edx*4]
$LN436@compile_br:

; 2854 :             {
; 2855 :             case ESC_d:
; 2856 :             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];

	xor	ecx, ecx
	npad	8
$LL435@compile_br:
	mov	dl, BYTE PTR [ecx+eax+64]
	or	BYTE PTR _classbits$[esp+ecx+216], dl
	add	ecx, 1
	cmp	ecx, 32					; 00000020H
	jl	SHORT $LL435@compile_br
$LN776@compile_br:

; 3241 :             }
; 3242 :           }
; 3243 : 
; 3244 :         continue;   /* Go get the next char in the class */

	mov	edi, DWORD PTR _ptr$[esp+216]
$LN484@compile_br:

; 3288 :         }
; 3289 :       }
; 3290 : 
; 3291 :     /* Loop until ']' reached. This "while" is the end of the "do" above. */
; 3292 : 
; 3293 :     while ((c = *(++ptr)) != 0 && (c != ']' || inescq));

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	esi, BYTE PTR [edi]
	test	esi, esi
	je	$LN681@compile_br
	cmp	esi, 93					; 0000005dH
	jne	$LL485@compile_br
	cmp	DWORD PTR _inescq$[esp+216], 0
	jne	$LL485@compile_br

; 3298 :       goto FAILED;
; 3299 :       }
; 3300 : 
; 3301 : 
; 3302 : /* This code has been disabled because it would mean that \s counts as
; 3303 : an explicit \r or \n reference, and that's not really what is wanted. Now
; 3304 : we set the flag only if there is a literal "\r" or "\n" in the class. */
; 3305 : 
; 3306 : #if 0
; 3307 :     /* Remember whether \r or \n are in this class */
; 3308 : 
; 3309 :     if (negate_class)
; 3310 :       {
; 3311 :       if ((classbits[1] & 0x24) != 0x24) cd->external_flags |= PCRE_HASCRORLF;
; 3312 :       }
; 3313 :     else
; 3314 :       {
; 3315 :       if ((classbits[1] & 0x24) != 0) cd->external_flags |= PCRE_HASCRORLF;
; 3316 :       }
; 3317 : #endif
; 3318 : 
; 3319 : 
; 3320 :     /* If class_charcount is 1, we saw precisely one character whose value is
; 3321 :     less than 256. As long as there were no characters >= 128 and there was no
; 3322 :     use of \p or \P, in other words, no use of any XCLASS features, we can
; 3323 :     optimize.
; 3324 : 
; 3325 :     In UTF-8 mode, we can optimize the negative case only if there were no
; 3326 :     characters >= 128 because OP_NOT and the related opcodes like OP_NOTSTAR
; 3327 :     operate on single-bytes only. This is an historical hangover. Maybe one day
; 3328 :     we can tidy these opcodes to handle multi-byte characters.
; 3329 : 
; 3330 :     The optimization throws away the bit map. We turn the item into a
; 3331 :     1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
; 3332 :     that OP_NOT does not support multibyte characters. In the positive case, it
; 3333 :     can cause firstbyte to be set. Otherwise, there can be no first char if
; 3334 :     this item is first, whatever repeat count may follow. In the case of
; 3335 :     reqbyte, save the previous value for reinstating. */
; 3336 : 
; 3337 : #ifdef SUPPORT_UTF8
; 3338 :     if (class_charcount == 1 && !class_utf8 &&
; 3339 :       (!utf8 || !negate_class || class_lastchar < 128))
; 3340 : #else
; 3341 :     if (class_charcount == 1)

	cmp	DWORD PTR _class_charcount$6011[esp+216], 1
	jne	$LN353@compile_br

; 3342 : #endif
; 3343 :       {
; 3344 :       zeroreqbyte = reqbyte;
; 3345 : 
; 3346 :       /* The OP_NOT opcode works on one-byte characters only. */
; 3347 : 
; 3348 :       if (negate_class)

	cmp	DWORD PTR _negate_class$6005[esp+216], 0
	mov	eax, DWORD PTR _reqbyte$[esp+216]
	mov	DWORD PTR _zeroreqbyte$[esp+216], eax
	je	$LN352@compile_br

; 3349 :         {
; 3350 :         if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;

	mov	eax, DWORD PTR _firstbyte$[esp+216]
	cmp	eax, -2					; fffffffeH
	jne	SHORT $LN351@compile_br
	or	eax, -1
	mov	DWORD PTR _firstbyte$[esp+216], eax
$LN351@compile_br:

; 3351 :         zerofirstbyte = firstbyte;
; 3352 :         *code++ = OP_NOT;
; 3353 :         *code++ = class_lastchar;

	mov	cl, BYTE PTR _class_lastchar$6012[esp+216]
	mov	BYTE PTR [ebp], 29			; 0000001dH
	add	ebp, 1
	mov	DWORD PTR _zerofirstbyte$[esp+216], eax
	mov	BYTE PTR [ebp], cl

; 3354 :         break;

	jmp	$LN882@compile_br
$LN432@compile_br:

; 2857 :             continue;
; 2858 : 
; 2859 :             case ESC_D:
; 2860 :             should_flip_negation = TRUE;

	mov	DWORD PTR _should_flip_negation$6006[esp+216], 1

; 2861 :             for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];

	xor	ecx, ecx
	npad	7
$LL431@compile_br:
	mov	dl, BYTE PTR [ecx+eax+64]
	not	dl
	or	BYTE PTR _classbits$[esp+ecx+216], dl
	add	ecx, 1
	cmp	ecx, 32					; 00000020H
	jl	SHORT $LL431@compile_br

; 2862 :             continue;

	jmp	$LN776@compile_br
$LN428@compile_br:

; 2863 : 
; 2864 :             case ESC_w:
; 2865 :             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];

	xor	ecx, ecx
	npad	7
$LL427@compile_br:
	mov	dl, BYTE PTR [ecx+eax+160]
	or	BYTE PTR _classbits$[esp+ecx+216], dl
	add	ecx, 1
	cmp	ecx, 32					; 00000020H
	jl	SHORT $LL427@compile_br

; 2866 :             continue;

	jmp	$LN776@compile_br
$LN424@compile_br:

; 2867 : 
; 2868 :             case ESC_W:
; 2869 :             should_flip_negation = TRUE;

	mov	DWORD PTR _should_flip_negation$6006[esp+216], 1

; 2870 :             for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];

	xor	ecx, ecx
$LL423@compile_br:
	mov	dl, BYTE PTR [ecx+eax+160]
	not	dl
	or	BYTE PTR _classbits$[esp+ecx+216], dl
	add	ecx, 1
	cmp	ecx, 32					; 00000020H
	jl	SHORT $LL423@compile_br

; 2871 :             continue;

	jmp	$LN776@compile_br
$LN420@compile_br:

; 2872 : 
; 2873 :             case ESC_s:
; 2874 :             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];

	mov	esi, eax
	lea	eax, DWORD PTR _classbits$[esp+216]
	xor	edx, edx
	sub	esi, eax
$LL419@compile_br:
	lea	ecx, DWORD PTR _classbits$[esp+edx+216]
	mov	al, BYTE PTR [esi+ecx]
	or	BYTE PTR [ecx], al
	add	edx, 1
	cmp	edx, 32					; 00000020H
	jl	SHORT $LL419@compile_br

; 2875 :             classbits[1] &= ~0x08;   /* Perl 5.004 onwards omits VT from \s */

	and	BYTE PTR _classbits$[esp+217], 247	; 000000f7H

; 2876 :             continue;

	jmp	$LN776@compile_br
$LN416@compile_br:

; 2877 : 
; 2878 :             case ESC_S:
; 2879 :             should_flip_negation = TRUE;
; 2880 :             for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];

	mov	esi, eax
	lea	ecx, DWORD PTR _classbits$[esp+216]
	xor	edx, edx
	mov	DWORD PTR _should_flip_negation$6006[esp+216], 1
	sub	esi, ecx
$LL415@compile_br:
	lea	ecx, DWORD PTR _classbits$[esp+edx+216]
	mov	al, BYTE PTR [esi+ecx]
	not	al
	or	BYTE PTR [ecx], al
	add	edx, 1
	cmp	edx, 32					; 00000020H
	jl	SHORT $LL415@compile_br

; 2881 :             classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */

	or	BYTE PTR _classbits$[esp+217], 8

; 2882 :             continue;

	jmp	$LN776@compile_br
$LN439@compile_br:

; 2883 : 
; 2884 :             default:    /* Not recognized; fall through */
; 2885 :             break;      /* Need "default" setting to stop compiler warning. */
; 2886 :             }
; 2887 : 
; 2888 :           /* In the pre-compile phase, just do the recognition. */
; 2889 : 
; 2890 :           else if (c == -ESC_d || c == -ESC_D || c == -ESC_w ||
; 2891 :                    c == -ESC_W || c == -ESC_s || c == -ESC_S) continue;

	cmp	esi, -7					; fffffff9H
	je	$LN776@compile_br
	cmp	esi, -6					; fffffffaH
	je	$LN776@compile_br
	cmp	esi, -11				; fffffff5H
	je	$LN776@compile_br
	cmp	esi, -10				; fffffff6H
	je	$LN776@compile_br
	cmp	esi, -9					; fffffff7H
	je	$LN776@compile_br
	cmp	esi, -8					; fffffff8H
	je	$LN776@compile_br
$LN410@compile_br:

; 2892 : 
; 2893 :           /* We need to deal with \H, \h, \V, and \v in both phases because
; 2894 :           they use extra memory. */
; 2895 : 
; 2896 :           if (-c == ESC_h)

	cmp	ecx, 18					; 00000012H
	jne	SHORT $LN408@compile_br

; 2897 :             {
; 2898 :             SETBIT(classbits, 0x09); /* VT */

	or	BYTE PTR _classbits$[esp+217], 2

; 2899 :             SETBIT(classbits, 0x20); /* SPACE */

	or	BYTE PTR _classbits$[esp+220], 1

; 2900 :             SETBIT(classbits, 0xa0); /* NSBP */

	or	BYTE PTR _classbits$[esp+236], 1

; 2901 : #ifdef SUPPORT_UTF8
; 2902 :             if (utf8)
; 2903 :               {
; 2904 :               class_utf8 = TRUE;
; 2905 :               *class_utf8data++ = XCL_SINGLE;
; 2906 :               class_utf8data += _pcre_ord2utf8(0x1680, class_utf8data);
; 2907 :               *class_utf8data++ = XCL_SINGLE;
; 2908 :               class_utf8data += _pcre_ord2utf8(0x180e, class_utf8data);
; 2909 :               *class_utf8data++ = XCL_RANGE;
; 2910 :               class_utf8data += _pcre_ord2utf8(0x2000, class_utf8data);
; 2911 :               class_utf8data += _pcre_ord2utf8(0x200A, class_utf8data);
; 2912 :               *class_utf8data++ = XCL_SINGLE;
; 2913 :               class_utf8data += _pcre_ord2utf8(0x202f, class_utf8data);
; 2914 :               *class_utf8data++ = XCL_SINGLE;
; 2915 :               class_utf8data += _pcre_ord2utf8(0x205f, class_utf8data);
; 2916 :               *class_utf8data++ = XCL_SINGLE;
; 2917 :               class_utf8data += _pcre_ord2utf8(0x3000, class_utf8data);
; 2918 :               }
; 2919 : #endif
; 2920 :             continue;

	jmp	$LN776@compile_br
$LN408@compile_br:

; 2921 :             }
; 2922 : 
; 2923 :           if (-c == ESC_H)

	cmp	ecx, 17					; 00000011H
	jne	SHORT $LN407@compile_br

; 2924 :             {
; 2925 :             for (c = 0; c < 32; c++)

	xor	eax, eax
	npad	7
$LL406@compile_br:

; 2926 :               {
; 2927 :               int x = 0xff;
; 2928 :               switch (c)

	mov	ecx, eax
	sub	ecx, 1
	mov	edx, 255				; 000000ffH
	je	SHORT $LN401@compile_br
	sub	ecx, 3
	je	SHORT $LN400@compile_br
	sub	ecx, 16					; 00000010H
	jne	SHORT $LN402@compile_br
$LN400@compile_br:

; 2931 :                 case 0x20/8: x ^= 1 << (0x20%8); break;
; 2932 :                 case 0xa0/8: x ^= 1 << (0xa0%8); break;

	mov	edx, 254				; 000000feH
	jmp	SHORT $LN402@compile_br
$LN401@compile_br:

; 2929 :                 {
; 2930 :                 case 0x09/8: x ^= 1 << (0x09%8); break;

	mov	edx, 253				; 000000fdH
$LN402@compile_br:

; 2933 :                 default: break;
; 2934 :                 }
; 2935 :               classbits[c] |= x;

	or	BYTE PTR _classbits$[esp+eax+216], dl
	add	eax, 1
	cmp	eax, 32					; 00000020H
	jl	SHORT $LL406@compile_br

; 2936 :               }
; 2937 : 
; 2938 : #ifdef SUPPORT_UTF8
; 2939 :             if (utf8)
; 2940 :               {
; 2941 :               class_utf8 = TRUE;
; 2942 :               *class_utf8data++ = XCL_RANGE;
; 2943 :               class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
; 2944 :               class_utf8data += _pcre_ord2utf8(0x167f, class_utf8data);
; 2945 :               *class_utf8data++ = XCL_RANGE;
; 2946 :               class_utf8data += _pcre_ord2utf8(0x1681, class_utf8data);
; 2947 :               class_utf8data += _pcre_ord2utf8(0x180d, class_utf8data);
; 2948 :               *class_utf8data++ = XCL_RANGE;
; 2949 :               class_utf8data += _pcre_ord2utf8(0x180f, class_utf8data);
; 2950 :               class_utf8data += _pcre_ord2utf8(0x1fff, class_utf8data);
; 2951 :               *class_utf8data++ = XCL_RANGE;
; 2952 :               class_utf8data += _pcre_ord2utf8(0x200B, class_utf8data);
; 2953 :               class_utf8data += _pcre_ord2utf8(0x202e, class_utf8data);
; 2954 :               *class_utf8data++ = XCL_RANGE;
; 2955 :               class_utf8data += _pcre_ord2utf8(0x2030, class_utf8data);
; 2956 :               class_utf8data += _pcre_ord2utf8(0x205e, class_utf8data);
; 2957 :               *class_utf8data++ = XCL_RANGE;
; 2958 :               class_utf8data += _pcre_ord2utf8(0x2060, class_utf8data);
; 2959 :               class_utf8data += _pcre_ord2utf8(0x2fff, class_utf8data);
; 2960 :               *class_utf8data++ = XCL_RANGE;
; 2961 :               class_utf8data += _pcre_ord2utf8(0x3001, class_utf8data);
; 2962 :               class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
; 2963 :               }
; 2964 : #endif
; 2965 :             continue;

	jmp	$LN776@compile_br
$LN407@compile_br:

; 2966 :             }
; 2967 : 
; 2968 :           if (-c == ESC_v)

	cmp	ecx, 20					; 00000014H
	jne	SHORT $LN397@compile_br

; 2969 :             {
; 2970 :             SETBIT(classbits, 0x0a); /* LF */
; 2971 :             SETBIT(classbits, 0x0b); /* VT */
; 2972 :             SETBIT(classbits, 0x0c); /* FF */
; 2973 :             SETBIT(classbits, 0x0d); /* CR */

	or	BYTE PTR _classbits$[esp+217], 60	; 0000003cH

; 2974 :             SETBIT(classbits, 0x85); /* NEL */

	or	BYTE PTR _classbits$[esp+232], 32	; 00000020H

; 2975 : #ifdef SUPPORT_UTF8
; 2976 :             if (utf8)
; 2977 :               {
; 2978 :               class_utf8 = TRUE;
; 2979 :               *class_utf8data++ = XCL_RANGE;
; 2980 :               class_utf8data += _pcre_ord2utf8(0x2028, class_utf8data);
; 2981 :               class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
; 2982 :               }
; 2983 : #endif
; 2984 :             continue;

	jmp	$LN776@compile_br
$LN397@compile_br:

; 2985 :             }
; 2986 : 
; 2987 :           if (-c == ESC_V)

	cmp	ecx, 19					; 00000013H
	jne	SHORT $LN396@compile_br

; 2988 :             {
; 2989 :             for (c = 0; c < 32; c++)

	xor	eax, eax
	npad	2
$LL395@compile_br:

; 2990 :               {
; 2991 :               int x = 0xff;
; 2992 :               switch (c)

	mov	ecx, eax
	sub	ecx, 1
	mov	edx, 255				; 000000ffH
	je	SHORT $LN390@compile_br
	sub	ecx, 15					; 0000000fH
	jne	SHORT $LN391@compile_br

; 2998 :                              break;
; 2999 :                 case 0x85/8: x ^= 1 << (0x85%8); break;

	mov	edx, 223				; 000000dfH
	jmp	SHORT $LN391@compile_br
$LN390@compile_br:

; 2993 :                 {
; 2994 :                 case 0x0a/8: x ^= 1 << (0x0a%8);
; 2995 :                              x ^= 1 << (0x0b%8);
; 2996 :                              x ^= 1 << (0x0c%8);
; 2997 :                              x ^= 1 << (0x0d%8);

	mov	edx, 195				; 000000c3H
$LN391@compile_br:

; 3000 :                 default: break;
; 3001 :                 }
; 3002 :               classbits[c] |= x;

	or	BYTE PTR _classbits$[esp+eax+216], dl
	add	eax, 1
	cmp	eax, 32					; 00000020H
	jl	SHORT $LL395@compile_br

; 3003 :               }
; 3004 : 
; 3005 : #ifdef SUPPORT_UTF8
; 3006 :             if (utf8)
; 3007 :               {
; 3008 :               class_utf8 = TRUE;
; 3009 :               *class_utf8data++ = XCL_RANGE;
; 3010 :               class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
; 3011 :               class_utf8data += _pcre_ord2utf8(0x2027, class_utf8data);
; 3012 :               *class_utf8data++ = XCL_RANGE;
; 3013 :               class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
; 3014 :               class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
; 3015 :               }
; 3016 : #endif
; 3017 :             continue;

	jmp	$LN776@compile_br
$LN396@compile_br:

; 3018 :             }
; 3019 : 
; 3020 :           /* We need to deal with \P and \p in both phases. */
; 3021 : 
; 3022 : #ifdef SUPPORT_UCP
; 3023 :           if (-c == ESC_p || -c == ESC_P)
; 3024 :             {
; 3025 :             BOOL negated;
; 3026 :             int pdata;
; 3027 :             int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
; 3028 :             if (ptype < 0) goto FAILED;
; 3029 :             class_utf8 = TRUE;
; 3030 :             *class_utf8data++ = ((-c == ESC_p) != negated)?
; 3031 :               XCL_PROP : XCL_NOTPROP;
; 3032 :             *class_utf8data++ = ptype;
; 3033 :             *class_utf8data++ = pdata;
; 3034 :             class_charcount -= 2;   /* Not a < 256 character */
; 3035 :             continue;
; 3036 :             }
; 3037 : #endif
; 3038 :           /* Unrecognized escapes are faulted if PCRE is running in its
; 3039 :           strict mode. By default, for compatibility with Perl, they are
; 3040 :           treated as literals. */
; 3041 : 
; 3042 :           if ((options & PCRE_EXTRA) != 0)

	test	bl, 64					; 00000040H
	jne	$LN666@compile_br

; 3046 :             }
; 3047 : 
; 3048 :           class_charcount -= 2;  /* Undo the default count from above */
; 3049 :           c = *ptr;              /* Get the final character and fall through */

	mov	edi, DWORD PTR _ptr$[esp+216]
	sub	DWORD PTR _class_charcount$6011[esp+216], 2
	movzx	esi, BYTE PTR [edi]
	jmp	$CHECK_RANGE$6098
$LN636@compile_br:

; 3082 : 
; 3083 :         /* If we hit \Q (not followed by \E) at this point, go into escaped
; 3084 :         mode. */
; 3085 : 
; 3086 :         while (*ptr == '\\' && ptr[1] == 'Q')

	cmp	BYTE PTR [edi], 92			; 0000005cH
	jne	SHORT $LN378@compile_br
	npad	3
$LL379@compile_br:
	cmp	BYTE PTR [edi+1], 81			; 00000051H
	jne	SHORT $LN378@compile_br

; 3087 :           {
; 3088 :           ptr += 2;

	add	edi, 2
	mov	DWORD PTR _ptr$[esp+216], edi

; 3089 :           if (*ptr == '\\' && ptr[1] == 'E') { ptr += 2; continue; }

	cmp	BYTE PTR [edi], 92			; 0000005cH
	jne	SHORT $LN377@compile_br
	cmp	BYTE PTR [edi+1], 69			; 00000045H
	jne	SHORT $LN377@compile_br
	add	edi, 2
	mov	DWORD PTR _ptr$[esp+216], edi
	cmp	BYTE PTR [edi], 92			; 0000005cH
	je	SHORT $LL379@compile_br

; 5117 :         }
; 5118 : 
; 5119 :       /* So are Unicode property matches, if supported. */
; 5120 : 
; 5121 : #ifdef SUPPORT_UCP
; 5122 :       else if (-c == ESC_P || -c == ESC_p)
; 5123 :         {
; 5124 :         BOOL negated;
; 5125 :         int pdata;
; 5126 :         int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
; 5127 :         if (ptype < 0) goto FAILED;
; 5128 :         previous = code;
; 5129 :         *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
; 5130 :         *code++ = ptype;
; 5131 :         *code++ = pdata;
; 5132 :         }
; 5133 : #else
; 5134 : 
; 5135 :       /* If Unicode properties are not supported, \X, \P, and \p are not
; 5136 :       allowed. */
; 5137 : 
; 5138 :       else if (-c == ESC_X || -c == ESC_P || -c == ESC_p)

	jmp	SHORT $LN378@compile_br
$LN377@compile_br:

; 3090 :           inescq = TRUE;

	mov	edx, 1
	mov	DWORD PTR _inescq$[esp+216], edx
$LN378@compile_br:

; 3091 :           break;
; 3092 :           }
; 3093 : 
; 3094 :         if (*ptr == 0 || (!inescq && *ptr == ']'))

	mov	al, BYTE PTR [edi]
	test	al, al
	je	$LN802@compile_br
	test	edx, edx
	jne	SHORT $LN801@compile_br
	cmp	al, 93					; 0000005dH
	je	$LN802@compile_br
$LN801@compile_br:

; 3097 :           goto LONE_SINGLE_CHARACTER;
; 3098 :           }
; 3099 : 
; 3100 : #ifdef SUPPORT_UTF8
; 3101 :         if (utf8)
; 3102 :           {                           /* Braces are required because the */
; 3103 :           GETCHARLEN(d, ptr, ptr);    /* macro generates multiple statements */
; 3104 :           }
; 3105 :         else
; 3106 : #endif
; 3107 :         d = *ptr;  /* Not UTF-8 mode */
; 3108 : 
; 3109 :         /* The second part of a range can be a single-character escape, but
; 3110 :         not any of the other escapes. Perl 5.6 treats a hyphen as a literal
; 3111 :         in such circumstances. */
; 3112 : 
; 3113 :         if (!inescq && d == '\\')

	cmp	DWORD PTR _inescq$[esp+216], 0
	movzx	ebx, al
	jne	SHORT $LN366@compile_br
	cmp	ebx, 92					; 0000005cH
	jne	SHORT $LN366@compile_br

; 3114 :           {
; 3115 :           d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);

	mov	ecx, DWORD PTR _cd$[esp+212]
	mov	edx, DWORD PTR [ecx+48]
	mov	edi, DWORD PTR _errorcodeptr$[esp+212]
	push	1
	push	edx
	lea	eax, DWORD PTR _ptr$[esp+224]
	push	edi
	push	eax
	mov	eax, DWORD PTR _options$[esp+232]
	call	_check_escape
	add	esp, 16					; 00000010H

; 3116 :           if (*errorcodeptr != 0) goto FAILED;

	cmp	DWORD PTR [edi], 0
	mov	ebx, eax
	jne	$LN789@compile_br

; 3117 : 
; 3118 :           /* \b is backspace; \X is literal X; \R is literal R; any other
; 3119 :           special means the '-' was literal */
; 3120 : 
; 3121 :           if (d < 0)

	test	ebx, ebx
	jge	SHORT $LN775@compile_br

; 3122 :             {
; 3123 :             if (d == -ESC_b) d = '\b';

	cmp	ebx, -5					; fffffffbH
	jne	$LN371@compile_br
	mov	ebx, 8
$LN775@compile_br:
	mov	edi, DWORD PTR _ptr$[esp+216]
$LN366@compile_br:

; 3129 :               }
; 3130 :             }
; 3131 :           }
; 3132 : 
; 3133 :         /* Check that the two values are in the correct order. Optimize
; 3134 :         one-character ranges */
; 3135 : 
; 3136 :         if (d < c)

	cmp	ebx, esi
	jl	$LN668@compile_br

; 3139 :           goto FAILED;
; 3140 :           }
; 3141 : 
; 3142 :         if (d == c) goto LONE_SINGLE_CHARACTER;  /* A few lines below */

	je	$LONE_SINGLE_CHARACTER$6226

; 3143 : 
; 3144 :         /* Remember \r or \n */
; 3145 : 
; 3146 :         if (d == '\r' || d == '\n') cd->external_flags |= PCRE_HASCRORLF;

	cmp	ebx, 13					; 0000000dH
	je	SHORT $LN362@compile_br
	cmp	ebx, 10					; 0000000aH
	jne	SHORT $LN363@compile_br
$LN362@compile_br:
	mov	eax, DWORD PTR _cd$[esp+212]
	or	DWORD PTR [eax+68], 32			; 00000020H
$LN363@compile_br:

; 3147 : 
; 3148 :         /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
; 3149 :         matching, we have to use an XCLASS with extra data items. Caseless
; 3150 :         matching for characters > 127 is available only if UCP support is
; 3151 :         available. */
; 3152 : 
; 3153 : #ifdef SUPPORT_UTF8
; 3154 :         if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
; 3155 :           {
; 3156 :           class_utf8 = TRUE;
; 3157 : 
; 3158 :           /* With UCP support, we can find the other case equivalents of
; 3159 :           the relevant characters. There may be several ranges. Optimize how
; 3160 :           they fit with the basic range. */
; 3161 : 
; 3162 : #ifdef SUPPORT_UCP
; 3163 :           if ((options & PCRE_CASELESS) != 0)
; 3164 :             {
; 3165 :             unsigned int occ, ocd;
; 3166 :             unsigned int cc = c;
; 3167 :             unsigned int origd = d;
; 3168 :             while (get_othercase_range(&cc, origd, &occ, &ocd))
; 3169 :               {
; 3170 :               if (occ >= (unsigned int)c &&
; 3171 :                   ocd <= (unsigned int)d)
; 3172 :                 continue;                          /* Skip embedded ranges */
; 3173 : 
; 3174 :               if (occ < (unsigned int)c  &&
; 3175 :                   ocd >= (unsigned int)c - 1)      /* Extend the basic range */
; 3176 :                 {                                  /* if there is overlap,   */
; 3177 :                 c = occ;                           /* noting that if occ < c */
; 3178 :                 continue;                          /* we can't have ocd > d  */
; 3179 :                 }                                  /* because a subrange is  */
; 3180 :               if (ocd > (unsigned int)d &&
; 3181 :                   occ <= (unsigned int)d + 1)      /* always shorter than    */
; 3182 :                 {                                  /* the basic range.       */
; 3183 :                 d = ocd;
; 3184 :                 continue;
; 3185 :                 }
; 3186 : 
; 3187 :               if (occ == ocd)
; 3188 :                 {
; 3189 :                 *class_utf8data++ = XCL_SINGLE;
; 3190 :                 }
; 3191 :               else
; 3192 :                 {
; 3193 :                 *class_utf8data++ = XCL_RANGE;
; 3194 :                 class_utf8data += _pcre_ord2utf8(occ, class_utf8data);
; 3195 :                 }
; 3196 :               class_utf8data += _pcre_ord2utf8(ocd, class_utf8data);
; 3197 :               }
; 3198 :             }
; 3199 : #endif  /* SUPPORT_UCP */
; 3200 : 
; 3201 :           /* Now record the original range, possibly modified for UCP caseless
; 3202 :           overlapping ranges. */
; 3203 : 
; 3204 :           *class_utf8data++ = XCL_RANGE;
; 3205 :           class_utf8data += _pcre_ord2utf8(c, class_utf8data);
; 3206 :           class_utf8data += _pcre_ord2utf8(d, class_utf8data);
; 3207 : 
; 3208 :           /* With UCP support, we are done. Without UCP support, there is no
; 3209 :           caseless matching for UTF-8 characters > 127; we can use the bit map
; 3210 :           for the smaller ones. */
; 3211 : 
; 3212 : #ifdef SUPPORT_UCP
; 3213 :           continue;    /* With next character in the class */
; 3214 : #else
; 3215 :           if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
; 3216 : 
; 3217 :           /* Adjust upper limit and fall through to set up the map */
; 3218 : 
; 3219 :           d = 127;
; 3220 : 
; 3221 : #endif  /* SUPPORT_UCP */
; 3222 :           }
; 3223 : #endif  /* SUPPORT_UTF8 */
; 3224 : 
; 3225 :         /* We use the bit map for all cases when not in UTF-8 mode; else
; 3226 :         ranges that lie entirely within 0-127 when there is UCP support; else
; 3227 :         for partial ranges without UCP support. */
; 3228 : 
; 3229 :         class_charcount += d - c + 1;

	mov	edx, DWORD PTR _class_charcount$6011[esp+216]
	mov	ecx, ebx
	sub	ecx, esi

; 3230 :         class_lastchar = d;
; 3231 : 
; 3232 :         /* We can save a bit of time by skipping this in the pre-compile. */
; 3233 : 
; 3234 :         if (lengthptr == NULL) for (; c <= d; c++)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	lea	eax, DWORD PTR [edx+ecx+1]
	mov	DWORD PTR _class_charcount$6011[esp+216], eax
	mov	DWORD PTR _class_lastchar$6012[esp+216], ebx
	jne	$LN484@compile_br
	cmp	esi, ebx
	jg	$LN484@compile_br
	mov	eax, DWORD PTR _options$[esp+216]
	and	eax, 1
	mov	DWORD PTR tv2889[esp+216], eax
$LL360@compile_br:

; 3235 :           {
; 3236 :           classbits[c/8] |= (1 << (c&7));

	mov	eax, esi
	cdq
	and	edx, 7
	add	eax, edx
	mov	ecx, esi
	and	ecx, 7
	mov	dl, 1
	shl	dl, cl
	sar	eax, 3
	lea	eax, DWORD PTR _classbits$[esp+eax+216]
	or	BYTE PTR [eax], dl

; 3237 :           if ((options & PCRE_CASELESS) != 0)

	cmp	DWORD PTR tv2889[esp+216], 0
	je	SHORT $LN359@compile_br

; 3238 :             {
; 3239 :             int uc = cd->fcc[c];           /* flip case */

	mov	eax, DWORD PTR _cd$[esp+212]
	mov	ecx, DWORD PTR [eax+4]
	movzx	ecx, BYTE PTR [ecx+esi]

; 3240 :             classbits[uc/8] |= (1 << (uc&7));

	mov	eax, ecx
	cdq
	and	edx, 7
	add	eax, edx
	and	ecx, 7
	mov	dl, 1
	sar	eax, 3
	shl	dl, cl
	lea	eax, DWORD PTR _classbits$[esp+eax+216]
	or	BYTE PTR [eax], dl
$LN359@compile_br:
	add	esi, 1
	cmp	esi, ebx
	jle	SHORT $LL360@compile_br

; 3241 :             }
; 3242 :           }
; 3243 : 
; 3244 :         continue;   /* Go get the next char in the class */

	jmp	$LN484@compile_br
$LN371@compile_br:

; 3124 :             else if (d == -ESC_X) d = 'X';

	cmp	ebx, -21				; ffffffebH
	jne	SHORT $LN369@compile_br
	mov	ebx, 88					; 00000058H
	jmp	$LN775@compile_br
$LN369@compile_br:

; 3125 :             else if (d == -ESC_R) d = 'R'; else

	cmp	ebx, -16				; fffffff0H
	jne	SHORT $LN367@compile_br
	mov	ebx, 82					; 00000052H
	jmp	$LN775@compile_br
$LN367@compile_br:

; 3126 :               {
; 3127 :               ptr = oldptr;

	mov	edi, DWORD PTR _oldptr$6095[esp+216]

; 3128 :               goto LONE_SINGLE_CHARACTER;  /* A few lines below */

	jmp	SHORT $LN866@compile_br
$LN802@compile_br:

; 3095 :           {
; 3096 :           ptr = oldptr;

	mov	edi, ecx
$LN866@compile_br:
	mov	DWORD PTR _ptr$[esp+216], edi
$LONE_SINGLE_CHARACTER$6226:

; 3245 :         }
; 3246 : 
; 3247 :       /* Handle a lone single character - we can get here for a normal
; 3248 :       non-escape char, or after \ that introduces a single character or for an
; 3249 :       apparent range that isn't. */
; 3250 : 
; 3251 :       LONE_SINGLE_CHARACTER:
; 3252 : 
; 3253 :       /* Handle a character that cannot go in the bit map */
; 3254 : 
; 3255 : #ifdef SUPPORT_UTF8
; 3256 :       if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
; 3257 :         {
; 3258 :         class_utf8 = TRUE;
; 3259 :         *class_utf8data++ = XCL_SINGLE;
; 3260 :         class_utf8data += _pcre_ord2utf8(c, class_utf8data);
; 3261 : 
; 3262 : #ifdef SUPPORT_UCP
; 3263 :         if ((options & PCRE_CASELESS) != 0)
; 3264 :           {
; 3265 :           unsigned int othercase;
; 3266 :           if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR)
; 3267 :             {
; 3268 :             *class_utf8data++ = XCL_SINGLE;
; 3269 :             class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
; 3270 :             }
; 3271 :           }
; 3272 : #endif  /* SUPPORT_UCP */
; 3273 : 
; 3274 :         }
; 3275 :       else
; 3276 : #endif  /* SUPPORT_UTF8 */
; 3277 : 
; 3278 :       /* Handle a single-byte character */
; 3279 :         {
; 3280 :         classbits[c/8] |= (1 << (c&7));

	mov	eax, esi
	cdq
	and	edx, 7
	add	eax, edx
	mov	ecx, esi
	and	ecx, 7
	mov	dl, 1
	shl	dl, cl
	sar	eax, 3
	lea	eax, DWORD PTR _classbits$[esp+eax+216]
	or	BYTE PTR [eax], dl

; 3281 :         if ((options & PCRE_CASELESS) != 0)

	test	BYTE PTR _options$[esp+216], 1
	je	SHORT $LN356@compile_br

; 3282 :           {
; 3283 :           c = cd->fcc[c];   /* flip case */

	mov	eax, DWORD PTR _cd$[esp+212]
	mov	ecx, DWORD PTR [eax+4]
	movzx	esi, BYTE PTR [ecx+esi]

; 3284 :           classbits[c/8] |= (1 << (c&7));

	mov	eax, esi
	cdq
	and	edx, 7
	add	eax, edx
	mov	ecx, esi
	and	ecx, 7
	mov	dl, 1
	sar	eax, 3
	shl	dl, cl
	lea	eax, DWORD PTR _classbits$[esp+eax+216]
	or	BYTE PTR [eax], dl
$LN356@compile_br:

; 3285 :           }
; 3286 :         class_charcount++;

	add	DWORD PTR _class_charcount$6011[esp+216], 1

; 3287 :         class_lastchar = c;

	mov	DWORD PTR _class_lastchar$6012[esp+216], esi
	jmp	$LN484@compile_br
$LN352@compile_br:

; 3355 :         }
; 3356 : 
; 3357 :       /* For a single, positive character, get the value into mcbuffer, and
; 3358 :       then we can handle this with the normal one-character code. */
; 3359 : 
; 3360 : #ifdef SUPPORT_UTF8
; 3361 :       if (utf8 && class_lastchar > 127)
; 3362 :         mclength = _pcre_ord2utf8(class_lastchar, mcbuffer);
; 3363 :       else
; 3364 : #endif
; 3365 :         {
; 3366 :         mcbuffer[0] = class_lastchar;

	mov	al, BYTE PTR _class_lastchar$6012[esp+216]

; 3367 :         mclength = 1;
; 3368 :         }
; 3369 :       goto ONE_CHAR;

	jmp	$ONE_CHAR$6253
$LN353@compile_br:

; 3370 :       }       /* End of 1-char optimization */
; 3371 : 
; 3372 :     /* The general case - not the one-char optimization. If this is the first
; 3373 :     thing in the branch, there can be no first char setting, whatever the
; 3374 :     repeat count. Any reqbyte setting must remain unchanged after any kind of
; 3375 :     repeat. */
; 3376 : 
; 3377 :     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;

	mov	eax, DWORD PTR _firstbyte$[esp+216]
	cmp	eax, -2					; fffffffeH
	jne	SHORT $LN350@compile_br
	or	eax, -1
	mov	DWORD PTR _firstbyte$[esp+216], eax
$LN350@compile_br:

; 3378 :     zerofirstbyte = firstbyte;
; 3379 :     zeroreqbyte = reqbyte;

	mov	edx, DWORD PTR _reqbyte$[esp+216]
	mov	DWORD PTR _zerofirstbyte$[esp+216], eax

; 3380 : 
; 3381 :     /* If there are characters with values > 255, we have to compile an
; 3382 :     extended class, with its own opcode, unless there was a negated special
; 3383 :     such as \S in the class, because in that case all characters > 255 are in
; 3384 :     the class, so any that were explicitly given as well can be ignored. If
; 3385 :     (when there are explicit characters > 255 that must be listed) there are no
; 3386 :     characters < 256, we can omit the bitmap in the actual compiled code. */
; 3387 : 
; 3388 : #ifdef SUPPORT_UTF8
; 3389 :     if (class_utf8 && !should_flip_negation)
; 3390 :       {
; 3391 :       *class_utf8data++ = XCL_END;    /* Marks the end of extra data */
; 3392 :       *code++ = OP_XCLASS;
; 3393 :       code += LINK_SIZE;
; 3394 :       *code = negate_class? XCL_NOT : 0;
; 3395 : 
; 3396 :       /* If the map is required, move up the extra data to make room for it;
; 3397 :       otherwise just move the code pointer to the end of the extra data. */
; 3398 : 
; 3399 :       if (class_charcount > 0)
; 3400 :         {
; 3401 :         *code++ |= XCL_MAP;
; 3402 :         memmove(code + 32, code, class_utf8data - code);
; 3403 :         memcpy(code, classbits, 32);
; 3404 :         code = class_utf8data + 32;
; 3405 :         }
; 3406 :       else code = class_utf8data;
; 3407 : 
; 3408 :       /* Now fill in the complete length of the item */
; 3409 : 
; 3410 :       PUT(previous, 1, code - previous);
; 3411 :       break;   /* End of class handling */
; 3412 :       }
; 3413 : #endif
; 3414 : 
; 3415 :     /* If there are no characters > 255, set the opcode to OP_CLASS or
; 3416 :     OP_NCLASS, depending on whether the whole class was negated and whether
; 3417 :     there were negative specials such as \S in the class. Then copy the 32-byte
; 3418 :     map into the code vector, negating it if necessary. */
; 3419 : 
; 3420 :     *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;

	mov	eax, DWORD PTR _negate_class$6005[esp+216]
	cmp	eax, DWORD PTR _should_flip_negation$6006[esp+216]
	mov	DWORD PTR _zeroreqbyte$[esp+216], edx
	setne	cl
	add	cl, 77					; 0000004dH
	mov	BYTE PTR [ebp], cl
	add	ebp, 1

; 3421 :     if (negate_class)

	test	eax, eax
	je	SHORT $LN349@compile_br

; 3422 :       {
; 3423 :       if (lengthptr == NULL)    /* Save time in the pre-compile phase */

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	jne	SHORT $LN805@compile_br

; 3424 :         for (c = 0; c < 32; c++) code[c] = ~classbits[c];

	lea	ecx, DWORD PTR _classbits$[esp+216]
	mov	eax, ebp
	sub	ecx, ebp
	mov	esi, 32					; 00000020H
	npad	5
$LL347@compile_br:
	mov	dl, BYTE PTR [ecx+eax]
	not	dl
	mov	BYTE PTR [eax], dl
	add	eax, 1
	sub	esi, 1
	jne	SHORT $LL347@compile_br

; 3429 :       }
; 3430 :     code += 32;

	add	ebp, 32					; 00000020H

; 3431 :     break;

	jmp	$LN884@compile_br
$LN349@compile_br:

; 3425 :       }
; 3426 :     else
; 3427 :       {
; 3428 :       memcpy(code, classbits, 32);

	mov	ecx, 8
	lea	esi, DWORD PTR _classbits$[esp+216]
	mov	edi, ebp
	rep movsd
$LN805@compile_br:

; 3429 :       }
; 3430 :     code += 32;

	add	ebp, 32					; 00000020H

; 3431 :     break;

	jmp	$LN884@compile_br
$LN343@compile_br:

; 3432 : 
; 3433 : 
; 3434 :     /* ===================================================================*/
; 3435 :     /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
; 3436 :     has been tested above. */
; 3437 : 
; 3438 :     case '{':
; 3439 :     if (!is_quantifier) goto NORMAL_CHAR;

	cmp	DWORD PTR _is_quantifier$6008[esp+216], 0
	je	$NORMAL_CHAR$6043

; 3440 :     ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);

	mov	esi, DWORD PTR _errorcodeptr$[esp+212]
	lea	eax, DWORD PTR _repeat_max$[esp+216]
	push	eax
	lea	ecx, DWORD PTR _repeat_min$[esp+220]
	lea	eax, DWORD PTR [edi+1]
	push	ecx
	mov	edi, esi
	call	_read_repeat_counts
	add	esp, 8

; 3441 :     if (*errorcodeptr != 0) goto FAILED;

	cmp	DWORD PTR [esi], 0
	mov	edi, eax
	mov	DWORD PTR _ptr$[esp+216], edi
	jne	$FAILED$6025

; 3442 :     goto REPEAT;

	mov	eax, DWORD PTR _repeat_min$[esp+216]
	jmp	SHORT $REPEAT$6265
$LN340@compile_br:

; 3443 : 
; 3444 :     case '*':
; 3445 :     repeat_min = 0;
; 3446 :     repeat_max = -1;

	mov	DWORD PTR _repeat_max$[esp+216], -1

; 3447 :     goto REPEAT;

	jmp	SHORT $LN867@compile_br
$LN339@compile_br:

; 3448 : 
; 3449 :     case '+':
; 3450 :     repeat_min = 1;

	mov	eax, 1

; 3451 :     repeat_max = -1;

	mov	DWORD PTR _repeat_max$[esp+216], -1

; 3452 :     goto REPEAT;

	jmp	SHORT $LN868@compile_br
$LN338@compile_br:

; 3456 :     repeat_max = 1;

	mov	DWORD PTR _repeat_max$[esp+216], 1
$LN867@compile_br:

; 3453 : 
; 3454 :     case '?':
; 3455 :     repeat_min = 0;

	xor	eax, eax
$LN868@compile_br:
	mov	DWORD PTR _repeat_min$[esp+216], eax
$REPEAT$6265:

; 3457 : 
; 3458 :     REPEAT:
; 3459 :     if (previous == NULL)

	mov	ecx, DWORD PTR _previous$[esp+216]
	xor	edx, edx
	cmp	ecx, edx
	je	$LN683@compile_br

; 3462 :       goto FAILED;
; 3463 :       }
; 3464 : 
; 3465 :     if (repeat_min == 0)

	cmp	eax, edx
	jne	SHORT $LN336@compile_br

; 3466 :       {
; 3467 :       firstbyte = zerofirstbyte;    /* Adjust for zero repeat */

	mov	esi, DWORD PTR _zerofirstbyte$[esp+216]
	mov	DWORD PTR _firstbyte$[esp+216], esi

; 3468 :       reqbyte = zeroreqbyte;        /* Ditto */

	mov	esi, DWORD PTR _zeroreqbyte$[esp+216]
	mov	DWORD PTR _reqbyte$[esp+216], esi
$LN336@compile_br:

; 3469 :       }
; 3470 : 
; 3471 :     /* Remember whether this is a variable length repeat */
; 3472 : 
; 3473 :     reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;

	sub	eax, DWORD PTR _repeat_max$[esp+216]

; 3474 : 
; 3475 :     op_type = 0;                    /* Default single-char op codes */
; 3476 :     possessive_quantifier = FALSE;  /* Default not possessive quantifier */
; 3477 : 
; 3478 :     /* Save start of previous item, in case we have to move it up to make space
; 3479 :     for an inserted OP_ONCE for the additional '+' extension. */
; 3480 : 
; 3481 :     tempcode = previous;

	mov	DWORD PTR _tempcode$[esp+216], ecx
	neg	eax
	sbb	eax, eax
	and	eax, 512				; 00000200H
	mov	DWORD PTR _reqvary$[esp+216], eax

; 3482 : 
; 3483 :     /* If the next character is '+', we have a possessive quantifier. This
; 3484 :     implies greediness, whatever the setting of the PCRE_UNGREEDY option.
; 3485 :     If the next character is '?' this is a minimizing repeat, by default,
; 3486 :     but if PCRE_UNGREEDY is set, it works the other way round. We change the
; 3487 :     repeat type to the non-default. */
; 3488 : 
; 3489 :     if (ptr[1] == '+')

	mov	al, BYTE PTR [edi+1]
	cmp	al, 43					; 0000002bH
	mov	DWORD PTR _op_type$[esp+216], edx
	mov	DWORD PTR _possessive_quantifier$6007[esp+216], edx
	jne	SHORT $LN335@compile_br

; 3490 :       {
; 3491 :       repeat_type = 0;                  /* Force greedy */

	xor	ebx, ebx
	add	edi, 1

; 3492 :       possessive_quantifier = TRUE;

	mov	DWORD PTR _possessive_quantifier$6007[esp+216], 1

; 3493 :       ptr++;

	mov	DWORD PTR _ptr$[esp+216], edi
	jmp	SHORT $LN332@compile_br
$LN335@compile_br:

; 3494 :       }
; 3495 :     else if (ptr[1] == '?')

	cmp	al, 63					; 0000003fH
	jne	SHORT $LN333@compile_br

; 3496 :       {
; 3497 :       repeat_type = greedy_non_default;

	mov	ebx, DWORD PTR _greedy_non_default$[esp+216]
	add	edi, 1

; 3498 :       ptr++;

	mov	DWORD PTR _ptr$[esp+216], edi
	jmp	SHORT $LN332@compile_br
$LN333@compile_br:

; 3499 :       }
; 3500 :     else repeat_type = greedy_default;

	mov	ebx, DWORD PTR _greedy_default$[esp+216]
$LN332@compile_br:

; 3501 : 
; 3502 :     /* If previous was a character match, abolish the item and generate a
; 3503 :     repeat item instead. If a char item has a minumum of more than one, ensure
; 3504 :     that it is set in reqbyte - it might not be if a sequence such as x{3} is
; 3505 :     the first thing in a branch because the x will have gone into firstbyte
; 3506 :     instead.  */
; 3507 : 
; 3508 :     if (*previous == OP_CHAR || *previous == OP_CHARNC)

	mov	esi, DWORD PTR _previous$[esp+216]
	mov	al, BYTE PTR [esi]
	cmp	al, 27					; 0000001bH
	je	$LN330@compile_br
	cmp	al, 28					; 0000001cH
	je	$LN330@compile_br

; 3547 :         }
; 3548 : 
; 3549 :       goto OUTPUT_SINGLE_REPEAT;   /* Code shared with single character types */
; 3550 :       }
; 3551 : 
; 3552 :     /* If previous was a single negated character ([^a] or similar), we use
; 3553 :     one of the special opcodes, replacing it. The code is shared with single-
; 3554 :     character repeats by setting opt_type to add a suitable offset into
; 3555 :     repeat_type. We can also test for auto-possessification. OP_NOT is
; 3556 :     currently used only for single-byte chars. */
; 3557 : 
; 3558 :     else if (*previous == OP_NOT)

	cmp	al, 29					; 0000001dH
	jne	SHORT $LN326@compile_br

; 3559 :       {
; 3560 :       op_type = OP_NOTSTAR - OP_STAR;  /* Use "not" opcodes */
; 3561 :       c = previous[1];
; 3562 :       if (!possessive_quantifier &&
; 3563 :           repeat_max < 0 &&
; 3564 :           check_auto_possessive(OP_NOT, c, utf8, NULL, ptr + 1, options, cd))

	cmp	DWORD PTR _possessive_quantifier$6007[esp+216], 0
	movzx	edx, BYTE PTR [esi+1]
	mov	DWORD PTR _op_type$[esp+216], 13	; 0000000dH
	mov	DWORD PTR _c$[esp+216], edx
	jne	$OUTPUT_SINGLE_REPEAT$6280
	cmp	DWORD PTR _repeat_max$[esp+216], 0
	jge	$OUTPUT_SINGLE_REPEAT$6280
	mov	eax, DWORD PTR _options$[esp+216]
	push	eax
	add	edi, 1
	push	edi
	push	0
	mov	ecx, edx
	push	ecx
	push	29					; 0000001dH

; 3565 :         {
; 3566 :         repeat_type = 0;    /* Force greedy */
; 3567 :         possessive_quantifier = TRUE;
; 3568 :         }

	jmp	$LN871@compile_br
$LN326@compile_br:

; 3569 :       goto OUTPUT_SINGLE_REPEAT;
; 3570 :       }
; 3571 : 
; 3572 :     /* If previous was a character type match (\d or similar), abolish it and
; 3573 :     create a suitable repeat item. The code is shared with single-character
; 3574 :     repeats by setting op_type to add a suitable offset into repeat_type. Note
; 3575 :     the the Unicode property types will be present only when SUPPORT_UCP is
; 3576 :     defined, but we don't wrap the little bits of code here because it just
; 3577 :     makes it horribly messy. */
; 3578 : 
; 3579 :     else if (*previous < OP_EODN)

	cmp	al, 22					; 00000016H
	jae	SHORT $LN323@compile_br

; 3580 :       {
; 3581 :       uschar *oldcode;
; 3582 :       int prop_type, prop_value;
; 3583 :       op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
; 3584 :       c = *previous;
; 3585 : 
; 3586 :       if (!possessive_quantifier &&
; 3587 :           repeat_max < 0 &&
; 3588 :           check_auto_possessive(c, 0, utf8, NULL, ptr + 1, options, cd))

	cmp	DWORD PTR _possessive_quantifier$6007[esp+216], 0
	movzx	edx, al
	mov	DWORD PTR _op_type$[esp+216], 26	; 0000001aH
	mov	DWORD PTR _c$[esp+216], edx
	jne	$OUTPUT_SINGLE_REPEAT$6280
	cmp	DWORD PTR _repeat_max$[esp+216], 0
	jge	$OUTPUT_SINGLE_REPEAT$6280
	mov	eax, DWORD PTR _options$[esp+216]
	push	eax
	add	edi, 1
	push	edi
	push	0
	push	0
	mov	ecx, edx
	push	ecx

; 3589 :         {
; 3590 :         repeat_type = 0;    /* Force greedy */
; 3591 :         possessive_quantifier = TRUE;

	jmp	$LN871@compile_br
$LN323@compile_br:

; 3731 : 
; 3732 :       /* For a repeated Unicode property match, there are two extra bytes that
; 3733 :       define the required property. */
; 3734 : 
; 3735 : #ifdef SUPPORT_UCP
; 3736 :       if (prop_type >= 0)
; 3737 :         {
; 3738 :         *code++ = prop_type;
; 3739 :         *code++ = prop_value;
; 3740 :         }
; 3741 : #endif
; 3742 :       }
; 3743 : 
; 3744 :     /* If previous was a character class or a back reference, we put the repeat
; 3745 :     stuff after it, but just skip the item if the repeat was {0,0}. */
; 3746 : 
; 3747 :     else if (*previous == OP_CLASS ||
; 3748 :              *previous == OP_NCLASS ||
; 3749 : #ifdef SUPPORT_UTF8
; 3750 :              *previous == OP_XCLASS ||
; 3751 : #endif
; 3752 :              *previous == OP_REF)

	cmp	al, 77					; 0000004dH
	je	$LN296@compile_br
	cmp	al, 78					; 0000004eH
	je	$LN296@compile_br
	cmp	al, 80					; 00000050H
	je	$LN296@compile_br

; 3784 :              *previous == OP_ONCE || *previous == OP_COND)

	cmp	al, 93					; 0000005dH
	je	SHORT $LN806@compile_br
	cmp	al, 94					; 0000005eH
	je	SHORT $LN806@compile_br
	cmp	al, 92					; 0000005cH
	je	SHORT $LN806@compile_br
	cmp	al, 95					; 0000005fH
	jne	$LN285@compile_br
$LN806@compile_br:

; 3785 :       {
; 3786 :       register int i;
; 3787 :       int ketoffset = 0;
; 3788 :       int len = code - previous;

	mov	edx, ebp
	sub	edx, esi

; 3789 :       uschar *bralink = NULL;
; 3790 : 
; 3791 :       /* Repeating a DEFINE group is pointless */
; 3792 : 
; 3793 :       if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)

	cmp	al, 95					; 0000005fH
	mov	DWORD PTR _ketoffset$6332[esp+216], 0
	mov	DWORD PTR _len$6333[esp+216], edx
	mov	DWORD PTR _bralink$6334[esp+216], 0
	jne	SHORT $LN283@compile_br
	cmp	BYTE PTR [esi+3], 101			; 00000065H
	je	$LN684@compile_br
$LN283@compile_br:

; 3796 :         goto FAILED;
; 3797 :         }
; 3798 : 
; 3799 :       /* If the maximum repeat count is unlimited, find the end of the bracket
; 3800 :       by scanning through from the start, and compute the offset back to it
; 3801 :       from the current code pointer. There may be an OP_OPT setting following
; 3802 :       the final KET, so we can't find the end just by going back from the code
; 3803 :       pointer. */
; 3804 : 
; 3805 :       if (repeat_max == -1)

	mov	eax, DWORD PTR _repeat_max$[esp+216]
	cmp	eax, -1
	jne	SHORT $LN282@compile_br

; 3806 :         {
; 3807 :         register uschar *ket = previous;

	mov	eax, esi
$LL281@compile_br:

; 3808 :         do ket += GET(ket, 1); while (*ket != OP_KET);

	xor	edx, edx
	mov	dh, BYTE PTR [eax+1]
	mov	dl, BYTE PTR [eax+2]
	add	eax, edx
	cmp	BYTE PTR [eax], 84			; 00000054H
	jne	SHORT $LL281@compile_br

; 3809 :         ketoffset = code - ket;

	mov	edx, ebp
	sub	edx, eax
	mov	eax, DWORD PTR _repeat_max$[esp+216]
	mov	DWORD PTR _ketoffset$6332[esp+216], edx
$LN282@compile_br:

; 3810 :         }
; 3811 : 
; 3812 :       /* The case of a zero minimum is special because of the need to stick
; 3813 :       OP_BRAZERO in front of it, and because the group appears once in the
; 3814 :       data, whereas in other cases it appears the minimum number of times. For
; 3815 :       this reason, it is simplest to treat this case separately, as otherwise
; 3816 :       the code gets far too messy. There are several special subcases when the
; 3817 :       minimum is zero. */
; 3818 : 
; 3819 :       if (repeat_min == 0)

	mov	edx, DWORD PTR _repeat_min$[esp+216]
	test	edx, edx
	jne	$LN278@compile_br

; 3820 :         {
; 3821 :         /* If the maximum is also zero, we just omit the group from the output
; 3822 :         altogether. */
; 3823 : 
; 3824 :         if (repeat_max == 0)

	test	eax, eax

; 3825 :           {
; 3826 :           code = previous;
; 3827 :           goto END_REPEAT;

	je	$LN875@compile_br

; 3828 :           }
; 3829 : 
; 3830 :         /* If the maximum is 1 or unlimited, we just have to stick in the
; 3831 :         BRAZERO and do no more at this point. However, we do need to adjust
; 3832 :         any OP_RECURSE calls inside the group that refer to the group itself or
; 3833 :         any internal or forward referenced group, because the offset is from
; 3834 :         the start of the whole regex. Temporarily terminate the pattern while
; 3835 :         doing this. */
; 3836 : 
; 3837 :         if (repeat_max <= 1)

	cmp	eax, 1

; 3838 :           {
; 3839 :           *code = OP_END;

	mov	BYTE PTR [ebp], dl
	jg	SHORT $LN276@compile_br

; 3840 :           adjust_recurse(previous, 1, utf8, cd, save_hwm);

	mov	eax, DWORD PTR _save_hwm$[esp+216]
	mov	ecx, DWORD PTR _cd$[esp+212]
	push	eax
	push	ecx
	push	1
	push	esi
	call	_adjust_recurse

; 3841 :           memmove(previous+1, previous, len);

	mov	edx, DWORD PTR _len$6333[esp+232]
	push	edx
	lea	edi, DWORD PTR [esi+1]
	push	esi
	push	edi
	call	_memmove

; 3842 :           code++;
; 3843 :           *previous++ = OP_BRAZERO + repeat_type;

	mov	al, bl
	add	esp, 28					; 0000001cH
	add	ebp, 1
	add	al, 102					; 00000066H
	mov	BYTE PTR [esi], al
	mov	DWORD PTR _previous$[esp+216], edi

; 3844 :           }
; 3845 : 
; 3846 :         /* If the maximum is greater than 1 and limited, we have to replicate
; 3847 :         in a nested fashion, sticking OP_BRAZERO before each set of brackets.
; 3848 :         The first one has to be handled carefully because it's the original
; 3849 :         copy, which has to be moved up. The remainder can be handled by code
; 3850 :         that is common with the non-zero minimum case below. We have to
; 3851 :         adjust the value or repeat_max, since one less copy is required. Once
; 3852 :         again, we may have to adjust any OP_RECURSE calls inside the group. */
; 3853 : 
; 3854 :         else

	jmp	SHORT $LN869@compile_br
$LN276@compile_br:

; 3855 :           {
; 3856 :           int offset;
; 3857 :           *code = OP_END;
; 3858 :           adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd, save_hwm);

	mov	ecx, DWORD PTR _save_hwm$[esp+216]
	mov	edx, DWORD PTR _cd$[esp+212]
	push	ecx
	push	edx
	push	4
	push	esi
	call	_adjust_recurse

; 3859 :           memmove(previous + 2 + LINK_SIZE, previous, len);

	mov	eax, DWORD PTR _len$6333[esp+232]
	push	eax
	lea	ecx, DWORD PTR [esi+4]
	push	esi
	push	ecx
	call	_memmove

; 3860 :           code += 2 + LINK_SIZE;
; 3861 :           *previous++ = OP_BRAZERO + repeat_type;

	mov	dl, bl
	add	dl, 102					; 00000066H
	mov	BYTE PTR [esi], dl
	add	esi, 1

; 3862 :           *previous++ = OP_BRA;

	mov	BYTE PTR [esi], 93			; 0000005dH
	add	esi, 1
	add	esp, 28					; 0000001cH
	add	ebp, 4

; 3863 : 
; 3864 :           /* We chain together the bracket offset fields that have to be
; 3865 :           filled in later when the ends of the brackets are reached. */
; 3866 : 
; 3867 :           offset = (bralink == NULL)? 0 : previous - bralink;
; 3868 :           bralink = previous;

	mov	DWORD PTR _bralink$6334[esp+216], esi

; 3869 :           PUTINC(previous, 0, offset);

	mov	BYTE PTR [esi], 0
	mov	BYTE PTR [esi+1], 0
	add	esi, 2
	mov	DWORD PTR _previous$[esp+216], esi
$LN869@compile_br:

; 3870 :           }
; 3871 : 
; 3872 :         repeat_max--;

	sub	DWORD PTR _repeat_max$[esp+216], 1

; 3873 :         }
; 3874 : 
; 3875 :       /* If the minimum is greater than zero, replicate the group as many
; 3876 :       times as necessary, and adjust the maximum to the number of subsequent
; 3877 :       copies that we need. If we set a first char from the group, and didn't
; 3878 :       set a required char, copy the latter from the former. If there are any
; 3879 :       forward reference subroutine calls in the group, there will be entries on
; 3880 :       the workspace list; replicate these with an appropriate increment. */
; 3881 : 
; 3882 :       else

	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	ecx, DWORD PTR _tempcode$[esp+216]
	mov	edx, DWORD PTR _repeat_max$[esp+216]
	mov	DWORD PTR _code$[esp+216], ebp
	jmp	$LN808@compile_br
$LN278@compile_br:

; 3883 :         {
; 3884 :         if (repeat_min > 1)

	cmp	edx, 1
	jle	$LN265@compile_br

; 3885 :           {
; 3886 :           /* In the pre-compile phase, we don't actually do the replication. We
; 3887 :           just adjust the length as if we had. Do some paranoid checks for
; 3888 :           potential integer overflow. */
; 3889 : 
; 3890 :           if (lengthptr != NULL)

	mov	edx, DWORD PTR _lengthptr$[esp+212]
	test	edx, edx
	je	SHORT $LN272@compile_br

; 3891 :             {
; 3892 :             int delta = (repeat_min - 1)*length_prevgroup;

	mov	eax, DWORD PTR _repeat_min$[esp+216]
	add	eax, -1
	mov	DWORD PTR tv3310[esp+216], eax
	imul	eax, DWORD PTR _length_prevgroup$[esp+216]

; 3893 :             if ((double)(repeat_min - 1)*(double)length_prevgroup >
; 3894 :                                                             (double)INT_MAX ||
; 3895 :                 OFLOW_MAX - *lengthptr < delta)

	fild	DWORD PTR tv3310[esp+216]
	fimul	DWORD PTR _length_prevgroup$[esp+216]
	mov	DWORD PTR _delta$6352[esp+216], eax
	fcomp	QWORD PTR __real@41dfffffffc00000
	fnstsw	ax
	test	ah, 65					; 00000041H
	je	$LN678@compile_br
	mov	eax, DWORD PTR [edx]
	mov	esi, 2147483627				; 7fffffebH
	sub	esi, eax
	cmp	esi, DWORD PTR _delta$6352[esp+216]
	jl	$LN678@compile_br

; 3896 :               {
; 3897 :               *errorcodeptr = ERR20;
; 3898 :               goto FAILED;
; 3899 :               }
; 3900 :             *lengthptr += delta;

	mov	esi, DWORD PTR _delta$6352[esp+216]
	add	eax, esi
	mov	DWORD PTR [edx], eax

; 3901 :             }
; 3902 : 
; 3903 :           /* This is compiling for real */
; 3904 : 
; 3905 :           else

	jmp	$LN265@compile_br
$LN272@compile_br:

; 3906 :             {
; 3907 :             if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;

	cmp	DWORD PTR _groupsetfirstbyte$[esp+216], 0
	je	SHORT $LN268@compile_br
	cmp	DWORD PTR _reqbyte$[esp+216], 0
	jge	SHORT $LN268@compile_br
	mov	eax, DWORD PTR _firstbyte$[esp+216]
	mov	DWORD PTR _reqbyte$[esp+216], eax
$LN268@compile_br:

; 3908 :             for (i = 1; i < repeat_min; i++)

	cmp	DWORD PTR _repeat_min$[esp+216], 1
	jle	$LN265@compile_br
	mov	ecx, DWORD PTR _repeat_min$[esp+216]
	mov	esi, DWORD PTR _save_hwm$[esp+216]
	mov	edi, DWORD PTR _cd$[esp+212]
	add	ecx, -1
	mov	DWORD PTR tv2653[esp+216], ecx
	npad	10
$LL267@compile_br:

; 3909 :               {
; 3910 :               uschar *hc;
; 3911 :               uschar *this_hwm = cd->hwm;
; 3912 :               memcpy(code, previous, len);

	mov	eax, DWORD PTR _len$6333[esp+216]
	mov	ecx, DWORD PTR _previous$[esp+216]
	mov	edx, DWORD PTR [edi+32]
	push	eax
	push	ecx
	push	ebp
	mov	DWORD PTR _this_hwm$6364[esp+228], edx
	call	_memcpy

; 3913 :               for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)

	mov	eax, DWORD PTR _len$6333[esp+228]
	add	esp, 12					; 0000000cH
	cmp	esi, DWORD PTR _this_hwm$6364[esp+216]
	jae	SHORT $LN262@compile_br
$LL264@compile_br:

; 3914 :                 {
; 3915 :                 PUT(cd->hwm, 0, GET(hc, 0) + len);

	mov	ecx, DWORD PTR [edi+32]
	xor	edx, edx
	mov	dh, BYTE PTR [esi]
	add	esi, 2
	mov	dl, BYTE PTR [esi-1]
	add	edx, eax
	sar	edx, 8
	mov	BYTE PTR [ecx], dl
	movzx	edx, BYTE PTR [esi-1]
	mov	ecx, DWORD PTR [edi+32]
	add	dl, al
	mov	BYTE PTR [ecx+1], dl

; 3916 :                 cd->hwm += LINK_SIZE;

	add	DWORD PTR [edi+32], 2
	cmp	esi, DWORD PTR _this_hwm$6364[esp+216]
	jb	SHORT $LL264@compile_br
$LN262@compile_br:

; 3917 :                 }
; 3918 :               save_hwm = this_hwm;

	mov	esi, DWORD PTR _this_hwm$6364[esp+216]

; 3919 :               code += len;

	add	ebp, eax
	sub	DWORD PTR tv2653[esp+216], 1
	mov	DWORD PTR _save_hwm$[esp+216], esi
	jne	SHORT $LL267@compile_br
	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	ecx, DWORD PTR _tempcode$[esp+216]
	mov	DWORD PTR _code$[esp+216], ebp
$LN265@compile_br:

; 3920 :               }
; 3921 :             }
; 3922 :           }
; 3923 : 
; 3924 :         if (repeat_max > 0) repeat_max -= repeat_min;

	mov	edx, DWORD PTR _repeat_max$[esp+216]
	test	edx, edx
	jle	SHORT $LN870@compile_br
	sub	edx, DWORD PTR _repeat_min$[esp+216]
	mov	DWORD PTR _repeat_max$[esp+216], edx
$LN808@compile_br:

; 3925 :         }
; 3926 : 
; 3927 :       /* This code is common to both the zero and non-zero minimum cases. If
; 3928 :       the maximum is limited, it replicates the group in a nested fashion,
; 3929 :       remembering the bracket starts on a stack. In the case of a zero minimum,
; 3930 :       the first one was set up above. In all cases the repeat_max now specifies
; 3931 :       the number of additional copies needed. Again, we must remember to
; 3932 :       replicate entries on the forward reference list. */
; 3933 : 
; 3934 :       if (repeat_max >= 0)

	test	edx, edx
$LN870@compile_br:
	jl	$LN260@compile_br

; 3935 :         {
; 3936 :         /* In the pre-compile phase, we don't actually do the replication. We
; 3937 :         just adjust the length as if we had. For each repetition we must add 1
; 3938 :         to the length for BRAZERO and for all but the last repetition we must
; 3939 :         add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
; 3940 :         paranoid checks to avoid integer overflow. */
; 3941 : 
; 3942 :         if (lengthptr != NULL && repeat_max > 0)

	mov	esi, DWORD PTR _lengthptr$[esp+212]
	test	esi, esi
	je	SHORT $LN259@compile_br
	test	edx, edx
	jle	SHORT $LN259@compile_br

; 3943 :           {
; 3944 :           int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
; 3945 :                       2 - 2*LINK_SIZE;   /* Last one doesn't nest */

	mov	eax, DWORD PTR _length_prevgroup$[esp+216]
	add	eax, 7
	mov	DWORD PTR tv3346[esp+216], eax
	imul	eax, edx

; 3946 :           if ((double)repeat_max *
; 3947 :                 (double)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
; 3948 :                   > (double)INT_MAX ||
; 3949 :               OFLOW_MAX - *lengthptr < delta)

	fild	DWORD PTR tv3346[esp+216]
	fimul	DWORD PTR _repeat_max$[esp+216]
	sub	eax, 6
	mov	edx, eax
	fcomp	QWORD PTR __real@41dfffffffc00000
	fnstsw	ax
	test	ah, 65					; 00000041H
	je	$LN686@compile_br
	mov	eax, DWORD PTR [esi]
	mov	ebx, 2147483627				; 7fffffebH
	sub	ebx, eax
	cmp	ebx, edx
	jl	$LN686@compile_br

; 3952 :             goto FAILED;
; 3953 :             }
; 3954 :           *lengthptr += delta;

	add	eax, edx
	mov	DWORD PTR [esi], eax
	jmp	$LN829@compile_br
$LN259@compile_br:

; 3955 :           }
; 3956 : 
; 3957 :         /* This is compiling for real */
; 3958 : 
; 3959 :         else for (i = repeat_max - 1; i >= 0; i--)

	add	edx, -1
	mov	DWORD PTR _i$6331[esp+216], edx
	js	$LN829@compile_br
	mov	edi, DWORD PTR _save_hwm$[esp+216]
	mov	esi, DWORD PTR _cd$[esp+212]
	add	bl, 102					; 00000066H

; 3980 :             {
; 3981 :             PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));

	mov	BYTE PTR tv3297[esp+216], bl
$LL255@compile_br:
	mov	edx, DWORD PTR [esi+32]
	mov	BYTE PTR [ebp], bl
	add	ebp, 1
	cmp	DWORD PTR _i$6331[esp+216], 0
	mov	DWORD PTR _this_hwm$6383[esp+216], edx
	je	SHORT $LN252@compile_br
	mov	ecx, DWORD PTR _bralink$6334[esp+216]
	mov	BYTE PTR [ebp], 93			; 0000005dH
	add	ebp, 1
	test	ecx, ecx
	jne	SHORT $LN553@compile_br

; 3960 :           {
; 3961 :           uschar *hc;
; 3962 :           uschar *this_hwm = cd->hwm;
; 3963 : 
; 3964 :           *code++ = OP_BRAZERO + repeat_type;
; 3965 : 
; 3966 :           /* All but the final copy start a new nesting, maintaining the
; 3967 :           chain of brackets outstanding. */
; 3968 : 
; 3969 :           if (i != 0)
; 3970 :             {
; 3971 :             int offset;
; 3972 :             *code++ = OP_BRA;
; 3973 :             offset = (bralink == NULL)? 0 : code - bralink;

	xor	eax, eax
	jmp	SHORT $LN554@compile_br
$LN553@compile_br:
	mov	eax, ebp
	sub	eax, ecx
$LN554@compile_br:

; 3974 :             bralink = code;
; 3975 :             PUTINC(code, 0, offset);

	mov	ecx, eax
	sar	ecx, 8
	mov	DWORD PTR _bralink$6334[esp+216], ebp
	mov	BYTE PTR [ebp], cl
	mov	BYTE PTR [ebp+1], al
	add	ebp, 2
$LN252@compile_br:

; 3976 :             }
; 3977 : 
; 3978 :           memcpy(code, previous, len);

	mov	edx, DWORD PTR _len$6333[esp+216]
	mov	eax, DWORD PTR _previous$[esp+216]
	push	edx
	push	eax
	push	ebp
	call	_memcpy
	add	esp, 12					; 0000000cH

; 3979 :           for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)

	cmp	edi, DWORD PTR _this_hwm$6383[esp+216]
	mov	eax, edi
	jae	SHORT $LN249@compile_br

; 3980 :             {
; 3981 :             PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));

	mov	ecx, DWORD PTR _i$6331[esp+216]
	mov	edi, ecx
	neg	edi
	sbb	edi, edi
	and	edi, 3
	add	edi, 1
	neg	ecx
	sbb	cl, cl
	and	cl, 3
	add	cl, 1
	npad	7
$LL835@compile_br:
	mov	ebx, DWORD PTR [esi+32]
	xor	edx, edx
	mov	dh, BYTE PTR [eax]
	add	eax, 2
	mov	dl, BYTE PTR [eax-1]
	add	edx, DWORD PTR _len$6333[esp+216]
	add	edx, edi
	sar	edx, 8
	mov	BYTE PTR [ebx], dl
	movzx	edx, BYTE PTR [eax-1]
	mov	ebx, DWORD PTR [esi+32]
	add	dl, cl
	add	dl, BYTE PTR _len$6333[esp+216]
	mov	BYTE PTR [ebx+1], dl

; 3982 :             cd->hwm += LINK_SIZE;

	add	DWORD PTR [esi+32], 2
	cmp	eax, DWORD PTR _this_hwm$6383[esp+216]
	jb	SHORT $LL835@compile_br

; 3979 :           for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)

	mov	bl, BYTE PTR tv3297[esp+216]
$LN249@compile_br:

; 3983 :             }
; 3984 :           save_hwm = this_hwm;

	mov	edi, DWORD PTR _this_hwm$6383[esp+216]

; 3985 :           code += len;

	add	ebp, DWORD PTR _len$6333[esp+216]
	sub	DWORD PTR _i$6331[esp+216], 1
	mov	DWORD PTR _save_hwm$[esp+216], edi
	jns	$LL255@compile_br
	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	ecx, DWORD PTR _tempcode$[esp+216]
	mov	DWORD PTR _code$[esp+216], ebp
$LN829@compile_br:
	mov	esi, DWORD PTR _bralink$6334[esp+216]

; 3986 :           }
; 3987 : 
; 3988 :         /* Now chain through the pending brackets, and fill in their length
; 3989 :         fields (which are holding the chain links pro tem). */
; 3990 : 
; 3991 :         while (bralink != NULL)

	test	esi, esi
	je	$LN811@compile_br
$LL248@compile_br:

; 3992 :           {
; 3993 :           int oldlinkoffset;
; 3994 :           int offset = code - bralink + 1;

	mov	eax, ebp
	sub	eax, esi
	add	eax, 1

; 3995 :           uschar *bra = code - offset;

	mov	ecx, ebp
	sub	ecx, eax

; 3996 :           oldlinkoffset = GET(bra, 1);

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

; 3997 :           bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;

	test	edx, edx
	jne	SHORT $LN555@compile_br
	xor	esi, esi
	jmp	SHORT $LN556@compile_br
$LN555@compile_br:
	sub	esi, edx
$LN556@compile_br:

; 3998 :           *code++ = OP_KET;

	mov	BYTE PTR [ebp], 84			; 00000054H
	add	ebp, 1

; 3999 :           PUTINC(code, 0, offset);

	mov	edx, eax
	sar	edx, 8
	mov	BYTE PTR [ebp], dl
	mov	BYTE PTR [ebp+1], al
	add	ebp, 2
	test	esi, esi

; 4000 :           PUT(bra, 1, offset);

	mov	BYTE PTR [ecx+1], dl
	mov	BYTE PTR [ecx+2], al
	jne	SHORT $LL248@compile_br

; 3999 :           PUTINC(code, 0, offset);

	mov	DWORD PTR _code$[esp+216], ebp

; 4001 :           }
; 4002 :         }
; 4003 : 
; 4004 :       /* If the maximum is unlimited, set a repeater in the final copy. We
; 4005 :       can't just offset backwards from the current code point, because we
; 4006 :       don't know if there's been an options resetting after the ket. The
; 4007 :       correct offset was computed above.
; 4008 : 
; 4009 :       Then, when we are doing the actual compile phase, check to see whether
; 4010 :       this group is a non-atomic one that could match an empty string. If so,
; 4011 :       convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
; 4012 :       that runtime checking can be done. [This check is also applied to
; 4013 :       atomic groups at runtime, but in a different way.] */
; 4014 : 
; 4015 :       else

	jmp	$LN778@compile_br
$LN260@compile_br:

; 4016 :         {
; 4017 :         uschar *ketcode = code - ketoffset;

	mov	esi, ebp
	sub	esi, DWORD PTR _ketoffset$6332[esp+216]

; 4018 :         uschar *bracode = ketcode - GET(ketcode, 1);

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

; 4019 :         *ketcode = OP_KETRMAX + repeat_type;

	add	bl, 85					; 00000055H
	mov	BYTE PTR [esi], bl
	mov	al, BYTE PTR [esi+2]
	sub	edi, eax

; 4020 :         if (lengthptr == NULL && *bracode != OP_ONCE)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	jne	$LN778@compile_br
	cmp	BYTE PTR [edi], 92			; 0000005cH
	je	$LN778@compile_br

; 4021 :           {
; 4022 :           uschar *scode = bracode;

	mov	ebx, edi
	npad	6
$LL244@compile_br:

; 4023 :           do
; 4024 :             {
; 4025 :             if (could_be_empty_branch(scode, ketcode, utf8))

	push	0
	push	esi
	push	ebx
	call	_could_be_empty_branch
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN669@compile_br

; 4028 :               break;
; 4029 :               }
; 4030 :             scode += GET(scode, 1);

	xor	ecx, ecx
	mov	ch, BYTE PTR [ebx+1]
	mov	cl, BYTE PTR [ebx+2]
	add	ebx, ecx

; 4031 :             }
; 4032 :           while (*scode == OP_ALT);

	cmp	BYTE PTR [ebx], 83			; 00000053H
	je	SHORT $LL244@compile_br
	jmp	$LN778@compile_br
$LN669@compile_br:

; 4026 :               {
; 4027 :               *bracode += OP_SBRA - OP_BRA;

	add	BYTE PTR [edi], 3

; 4033 :           }
; 4034 :         }
; 4035 :       }
; 4036 : 
; 4037 :     /* Else there's some kind of shambles */
; 4038 : 
; 4039 :     else

	jmp	$LN778@compile_br
$LN296@compile_br:

; 3753 :       {
; 3754 :       if (repeat_max == 0)

	mov	eax, DWORD PTR _repeat_max$[esp+216]
	test	eax, eax

; 3757 :         goto END_REPEAT;

	je	$LN875@compile_br

; 3758 :         }
; 3759 : 
; 3760 :       /* All real repeats make it impossible to handle partial matching (maybe
; 3761 :       one day we will be able to remove this restriction). */
; 3762 : 
; 3763 :       if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL;

	cmp	eax, 1
	je	SHORT $LN294@compile_br
	mov	ecx, DWORD PTR _cd$[esp+212]
	or	DWORD PTR [ecx+68], 1
$LN294@compile_br:

; 3764 : 
; 3765 :       if (repeat_min == 0 && repeat_max == -1)

	mov	ecx, DWORD PTR _repeat_min$[esp+216]
	test	ecx, ecx
	jne	SHORT $LN293@compile_br
	cmp	eax, -1
	jne	SHORT $LN759@compile_br

; 3766 :         *code++ = OP_CRSTAR + repeat_type;

	add	bl, 69					; 00000045H
	mov	BYTE PTR [ebp], bl
	add	ebp, 1
	mov	DWORD PTR _code$[esp+216], ebp
	jmp	$LN778@compile_br
$LN293@compile_br:

; 3767 :       else if (repeat_min == 1 && repeat_max == -1)

	cmp	ecx, 1
	jne	SHORT $LN830@compile_br
	cmp	eax, -1
	jne	SHORT $LN830@compile_br

; 3768 :         *code++ = OP_CRPLUS + repeat_type;

	add	bl, 71					; 00000047H
	mov	BYTE PTR [ebp], bl
	add	ebp, 1
	mov	DWORD PTR _code$[esp+216], ebp
	jmp	$LN778@compile_br
$LN759@compile_br:

; 3769 :       else if (repeat_min == 0 && repeat_max == 1)

	cmp	eax, 1
	jne	SHORT $LN830@compile_br

; 3770 :         *code++ = OP_CRQUERY + repeat_type;

	add	bl, 73					; 00000049H
	mov	BYTE PTR [ebp], bl
	add	ebp, 1
	mov	DWORD PTR _code$[esp+216], ebp

; 3771 :       else

	jmp	$LN778@compile_br
$LN830@compile_br:

; 3772 :         {
; 3773 :         *code++ = OP_CRRANGE + repeat_type;

	add	bl, 75					; 0000004bH
	mov	BYTE PTR [ebp], bl
	add	ebp, 1

; 3774 :         PUT2INC(code, 0, repeat_min);

	mov	edx, ecx
	sar	edx, 8
	mov	BYTE PTR [ebp], dl
	mov	BYTE PTR [ebp+1], cl
	add	ebp, 2

; 3775 :         if (repeat_max == -1) repeat_max = 0;  /* 2-byte encoding for max */

	cmp	eax, -1
	jne	SHORT $LN287@compile_br
	xor	eax, eax
	mov	DWORD PTR _repeat_max$[esp+216], eax
$LN287@compile_br:

; 3776 :         PUT2INC(code, 0, repeat_max);

	mov	ecx, eax
	sar	ecx, 8
	mov	BYTE PTR [ebp], cl
	mov	BYTE PTR [ebp+1], al
	add	ebp, 2
	mov	DWORD PTR _code$[esp+216], ebp

; 3777 :         }
; 3778 :       }
; 3779 : 
; 3780 :     /* If previous was a bracket group, we may have to replicate it in certain
; 3781 :     cases. */
; 3782 : 
; 3783 :     else if (*previous == OP_BRA  || *previous == OP_CBRA ||

	jmp	$LN778@compile_br
$LN330@compile_br:

; 3509 :       {
; 3510 :       /* Deal with UTF-8 characters that take up more than one byte. It's
; 3511 :       easier to write this out separately than try to macrify it. Use c to
; 3512 :       hold the length of the character in bytes, plus 0x80 to flag that it's a
; 3513 :       length rather than a small character. */
; 3514 : 
; 3515 : #ifdef SUPPORT_UTF8
; 3516 :       if (utf8 && (code[-1] & 0x80) != 0)
; 3517 :         {
; 3518 :         uschar *lastchar = code - 1;
; 3519 :         while((*lastchar & 0xc0) == 0x80) lastchar--;
; 3520 :         c = code - lastchar;            /* Length of UTF-8 character */
; 3521 :         memcpy(utf8_char, lastchar, c); /* Save the char */
; 3522 :         c |= 0x80;                      /* Flag c as a length */
; 3523 :         }
; 3524 :       else
; 3525 : #endif
; 3526 : 
; 3527 :       /* Handle the case of a single byte - either with no UTF8 support, or
; 3528 :       with UTF-8 disabled, or for a UTF-8 character < 128. */
; 3529 : 
; 3530 :         {
; 3531 :         c = code[-1];
; 3532 :         if (repeat_min > 1) reqbyte = c | req_caseopt | cd->req_varyopt;

	cmp	DWORD PTR _repeat_min$[esp+216], 1
	movzx	edx, BYTE PTR [ebp-1]
	mov	DWORD PTR _c$[esp+216], edx
	jle	SHORT $LN831@compile_br
	mov	ecx, DWORD PTR _cd$[esp+212]
	mov	ecx, DWORD PTR [ecx+72]
	or	ecx, edx
	or	ecx, DWORD PTR _req_caseopt$[esp+216]
	mov	DWORD PTR _reqbyte$[esp+216], ecx
$LN831@compile_br:

; 3533 :         }
; 3534 : 
; 3535 :       /* If the repetition is unlimited, it pays to see if the next thing on
; 3536 :       the line is something that cannot possibly match this character. If so,
; 3537 :       automatically possessifying this item gains some performance in the case
; 3538 :       where the match fails. */
; 3539 : 
; 3540 :       if (!possessive_quantifier &&
; 3541 :           repeat_max < 0 &&
; 3542 :           check_auto_possessive(*previous, c, utf8, utf8_char, ptr + 1,
; 3543 :             options, cd))

	cmp	DWORD PTR _possessive_quantifier$6007[esp+216], 0
	jne	SHORT $OUTPUT_SINGLE_REPEAT$6280
	cmp	DWORD PTR _repeat_max$[esp+216], 0
	jge	SHORT $OUTPUT_SINGLE_REPEAT$6280
	mov	edx, DWORD PTR _options$[esp+216]
	mov	ecx, DWORD PTR _c$[esp+216]
	push	edx
	add	edi, 1
	push	edi
	push	0
	movzx	edx, al
	push	ecx
	push	edx
$LN871@compile_br:
	mov	edi, DWORD PTR _cd$[esp+232]
	call	_check_auto_possessive
	add	esp, 20					; 00000014H
	test	eax, eax
	je	SHORT $LN832@compile_br

; 3544 :         {
; 3545 :         repeat_type = 0;    /* Force greedy */
; 3546 :         possessive_quantifier = TRUE;

	mov	DWORD PTR _possessive_quantifier$6007[esp+216], 1
	xor	ebx, ebx
$LN832@compile_br:

; 3565 :         {
; 3566 :         repeat_type = 0;    /* Force greedy */
; 3567 :         possessive_quantifier = TRUE;
; 3568 :         }

	mov	edi, DWORD PTR _ptr$[esp+216]
$OUTPUT_SINGLE_REPEAT$6280:

; 3592 :         }
; 3593 : 
; 3594 :       OUTPUT_SINGLE_REPEAT:
; 3595 :       if (*previous == OP_PROP || *previous == OP_NOTPROP)

	mov	al, BYTE PTR [esi]
	cmp	al, 15					; 0000000fH
	je	SHORT $LN809@compile_br
	cmp	al, 14					; 0000000eH
	je	SHORT $LN809@compile_br

; 3599 :         }
; 3600 :       else prop_type = prop_value = -1;

	or	eax, -1
	mov	DWORD PTR _prop_value$6289[esp+216], eax
	jmp	SHORT $LN872@compile_br
$LN809@compile_br:

; 3596 :         {
; 3597 :         prop_type = previous[1];
; 3598 :         prop_value = previous[2];

	movzx	ecx, BYTE PTR [esi+2]
	movzx	eax, BYTE PTR [esi+1]
	mov	DWORD PTR _prop_value$6289[esp+216], ecx
$LN872@compile_br:
	mov	DWORD PTR _prop_type$6288[esp+216], eax

; 3601 : 
; 3602 :       oldcode = code;
; 3603 :       code = previous;                  /* Usually overwrite previous item */
; 3604 : 
; 3605 :       /* If the maximum is zero then the minimum must also be zero; Perl allows
; 3606 :       this case, so we do too - by simply omitting the item altogether. */
; 3607 : 
; 3608 :       if (repeat_max == 0) goto END_REPEAT;

	mov	eax, DWORD PTR _repeat_max$[esp+216]
	test	eax, eax
	mov	DWORD PTR _code$[esp+216], esi
	je	$LN813@compile_br

; 3609 : 
; 3610 :       /* All real repeats make it impossible to handle partial matching (maybe
; 3611 :       one day we will be able to remove this restriction). */
; 3612 : 
; 3613 :       if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL;

	cmp	eax, 1
	je	SHORT $LN317@compile_br
	mov	ecx, DWORD PTR _cd$[esp+212]
	or	DWORD PTR [ecx+68], 1
$LN317@compile_br:

; 3614 : 
; 3615 :       /* Combine the op_type with the repeat_type */
; 3616 : 
; 3617 :       repeat_type += op_type;

	mov	ecx, DWORD PTR _op_type$[esp+216]
	add	ebx, ecx

; 3618 : 
; 3619 :       /* A minimum of zero is handled either as the special case * or ?, or as
; 3620 :       an UPTO, with the maximum given. */
; 3621 : 
; 3622 :       if (repeat_min == 0)

	cmp	DWORD PTR _repeat_min$[esp+216], 0
	jne	SHORT $LN316@compile_br

; 3623 :         {
; 3624 :         if (repeat_max == -1) *code++ = OP_STAR + repeat_type;

	cmp	eax, -1
	jne	SHORT $LN315@compile_br
	add	bl, 30					; 0000001eH
	mov	BYTE PTR [esi], bl
	add	esi, 1
	jmp	$LN873@compile_br
$LN315@compile_br:

; 3625 :           else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;

	cmp	eax, 1
	jne	SHORT $LN313@compile_br
	add	bl, 34					; 00000022H
	mov	BYTE PTR [esi], bl
	add	esi, eax

; 3626 :         else

	jmp	$LN873@compile_br
$LN313@compile_br:

; 3627 :           {
; 3628 :           *code++ = OP_UPTO + repeat_type;

	add	bl, 36					; 00000024H
	mov	BYTE PTR [esi], bl
	add	esi, 1

; 3629 :           PUT2INC(code, 0, repeat_max);

	mov	edx, eax
	sar	edx, 8
	mov	BYTE PTR [esi], dl

; 3630 :           }

	jmp	$LN874@compile_br
$LN316@compile_br:

; 3631 :         }
; 3632 : 
; 3633 :       /* A repeat minimum of 1 is optimized into some special cases. If the
; 3634 :       maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
; 3635 :       left in place and, if the maximum is greater than 1, we use OP_UPTO with
; 3636 :       one less than the maximum. */
; 3637 : 
; 3638 :       else if (repeat_min == 1)

	cmp	DWORD PTR _repeat_min$[esp+216], 1
	jne	SHORT $LN310@compile_br

; 3639 :         {
; 3640 :         if (repeat_max == -1)

	cmp	eax, -1
	jne	SHORT $LN309@compile_br

; 3641 :           *code++ = OP_PLUS + repeat_type;

	add	bl, 32					; 00000020H
	mov	BYTE PTR [esi], bl
	add	esi, 1

; 3642 :         else

	jmp	$LN873@compile_br
$LN309@compile_br:

; 3643 :           {
; 3644 :           code = oldcode;                 /* leave previous item in place */
; 3645 :           if (repeat_max == 1) goto END_REPEAT;

	cmp	eax, 1
	mov	DWORD PTR _code$[esp+216], ebp
	je	$LN813@compile_br

; 3646 :           *code++ = OP_UPTO + repeat_type;
; 3647 :           PUT2INC(code, 0, repeat_max - 1);

	lea	edx, DWORD PTR [eax-1]
	add	bl, 36					; 00000024H
	lea	ecx, DWORD PTR [ebp+1]
	sar	edx, 8
	sub	al, 1
	mov	BYTE PTR [ebp], bl
	mov	BYTE PTR [ecx], dl
	mov	BYTE PTR [ecx+1], al
	add	ecx, 2
	mov	DWORD PTR _code$[esp+216], ecx

; 3648 :           }
; 3649 :         }
; 3650 : 
; 3651 :       /* The case {n,n} is just an EXACT, while the general case {n,m} is
; 3652 :       handled as an EXACT followed by an UPTO. */
; 3653 : 
; 3654 :       else

	jmp	$LN810@compile_br
$LN310@compile_br:

; 3655 :         {
; 3656 :         *code++ = OP_EXACT + op_type;  /* NB EXACT doesn't have repeat_type */

	add	cl, 38					; 00000026H
	mov	BYTE PTR [esi], cl

; 3657 :         PUT2INC(code, 0, repeat_min);

	mov	ecx, DWORD PTR _repeat_min$[esp+216]
	add	esi, 1
	mov	edx, ecx
	sar	edx, 8
	mov	BYTE PTR [esi], dl
	mov	BYTE PTR [esi+1], cl
	add	esi, 2

; 3658 : 
; 3659 :         /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
; 3660 :         we have to insert the character for the previous code. For a repeated
; 3661 :         Unicode property match, there are two extra bytes that define the
; 3662 :         required property. In UTF-8 mode, long characters have their length in
; 3663 :         c, with the 0x80 bit as a flag. */
; 3664 : 
; 3665 :         if (repeat_max < 0)

	test	eax, eax
	mov	DWORD PTR _code$[esp+216], esi
	jge	SHORT $LN305@compile_br

; 3666 :           {
; 3667 : #ifdef SUPPORT_UTF8
; 3668 :           if (utf8 && c >= 128)
; 3669 :             {
; 3670 :             memcpy(code, utf8_char, c & 7);
; 3671 :             code += c & 7;
; 3672 :             }
; 3673 :           else
; 3674 : #endif
; 3675 :             {
; 3676 :             *code++ = c;

	mov	al, BYTE PTR _c$[esp+216]
	mov	BYTE PTR [esi], al

; 3677 :             if (prop_type >= 0)

	mov	eax, DWORD PTR _prop_type$6288[esp+216]
	add	esi, 1
	test	eax, eax
	jl	SHORT $LN304@compile_br

; 3678 :               {
; 3679 :               *code++ = prop_type;
; 3680 :               *code++ = prop_value;

	mov	cl, BYTE PTR _prop_value$6289[esp+216]
	mov	BYTE PTR [esi], al
	add	esi, 1
	mov	BYTE PTR [esi], cl
	add	esi, 1
$LN304@compile_br:

; 3681 :               }
; 3682 :             }
; 3683 :           *code++ = OP_STAR + repeat_type;

	add	bl, 30					; 0000001eH
	mov	BYTE PTR [esi], bl
	add	esi, 1
	jmp	SHORT $LN873@compile_br
$LN305@compile_br:

; 3684 :           }
; 3685 : 
; 3686 :         /* Else insert an UPTO if the max is greater than the min, again
; 3687 :         preceded by the character, for the previously inserted code. If the
; 3688 :         UPTO is just for 1 instance, we can use QUERY instead. */
; 3689 : 
; 3690 :         else if (repeat_max != repeat_min)

	cmp	eax, ecx
	je	SHORT $LN810@compile_br

; 3691 :           {
; 3692 : #ifdef SUPPORT_UTF8
; 3693 :           if (utf8 && c >= 128)
; 3694 :             {
; 3695 :             memcpy(code, utf8_char, c & 7);
; 3696 :             code += c & 7;
; 3697 :             }
; 3698 :           else
; 3699 : #endif
; 3700 :           *code++ = c;

	mov	esi, DWORD PTR _code$[esp+216]
	mov	dl, BYTE PTR _c$[esp+216]
	mov	BYTE PTR [esi], dl
	add	esi, 1

; 3701 :           if (prop_type >= 0)

	cmp	DWORD PTR _prop_type$6288[esp+216], 0
	jl	SHORT $LN859@compile_br

; 3702 :             {
; 3703 :             *code++ = prop_type;

	movzx	edx, BYTE PTR _prop_type$6288[esp+216]
	mov	BYTE PTR [esi], dl

; 3704 :             *code++ = prop_value;

	movzx	edx, BYTE PTR _prop_value$6289[esp+216]
	add	esi, 1
	mov	BYTE PTR [esi], dl
	add	esi, 1
$LN859@compile_br:

; 3705 :             }
; 3706 :           repeat_max -= repeat_min;

	sub	eax, ecx

; 3707 : 
; 3708 :           if (repeat_max == 1)

	cmp	eax, 1
	mov	DWORD PTR _repeat_max$[esp+216], eax
	jne	SHORT $LN300@compile_br

; 3709 :             {
; 3710 :             *code++ = OP_QUERY + repeat_type;

	add	bl, 34					; 00000022H
	mov	BYTE PTR [esi], bl
	add	esi, eax

; 3711 :             }
; 3712 :           else

	jmp	SHORT $LN873@compile_br
$LN300@compile_br:

; 3713 :             {
; 3714 :             *code++ = OP_UPTO + repeat_type;

	add	bl, 36					; 00000024H
	mov	BYTE PTR [esi], bl
	add	esi, 1

; 3715 :             PUT2INC(code, 0, repeat_max);

	mov	ecx, eax
	sar	ecx, 8
	mov	BYTE PTR [esi], cl
$LN874@compile_br:
	mov	BYTE PTR [esi+1], al
	add	esi, 2
$LN873@compile_br:
	mov	DWORD PTR _code$[esp+216], esi
$LN810@compile_br:

; 3716 :             }
; 3717 :           }
; 3718 :         }
; 3719 : 
; 3720 :       /* The character or character type itself comes last in all cases. */
; 3721 : 
; 3722 : #ifdef SUPPORT_UTF8
; 3723 :       if (utf8 && c >= 128)
; 3724 :         {
; 3725 :         memcpy(code, utf8_char, c & 7);
; 3726 :         code += c & 7;
; 3727 :         }
; 3728 :       else
; 3729 : #endif
; 3730 :       *code++ = c;

	mov	eax, DWORD PTR _code$[esp+216]
	mov	dl, BYTE PTR _c$[esp+216]
	mov	BYTE PTR [eax], dl
	add	eax, 1
	mov	DWORD PTR _code$[esp+216], eax
	mov	ebp, eax
$LN778@compile_br:

; 3777 :         }
; 3778 :       }
; 3779 : 
; 3780 :     /* If previous was a bracket group, we may have to replicate it in certain
; 3781 :     cases. */
; 3782 : 
; 3783 :     else if (*previous == OP_BRA  || *previous == OP_CBRA ||

	mov	ecx, DWORD PTR _tempcode$[esp+216]
	mov	edi, DWORD PTR _ptr$[esp+216]
$LN811@compile_br:

; 4042 :       goto FAILED;
; 4043 :       }
; 4044 : 
; 4045 :     /* If the character following a repeat is '+', or if certain optimization
; 4046 :     tests above succeeded, possessive_quantifier is TRUE. For some of the
; 4047 :     simpler opcodes, there is an special alternative opcode for this. For
; 4048 :     anything else, we wrap the entire repeated item inside OP_ONCE brackets.
; 4049 :     The '+' notation is just syntactic sugar, taken from Sun's Java package,
; 4050 :     but the special opcodes can optimize it a bit. The repeated item starts at
; 4051 :     tempcode, not at previous, which might be the first part of a string whose
; 4052 :     (former) last char we repeated.
; 4053 : 
; 4054 :     Possessifying an 'exact' quantifier has no effect, so we can ignore it. But
; 4055 :     an 'upto' may follow. We skip over an 'exact' item, and then test the
; 4056 :     length of what remains before proceeding. */
; 4057 : 
; 4058 :     if (possessive_quantifier)

	cmp	DWORD PTR _possessive_quantifier$6007[esp+216], 0
	je	$END_REPEAT$6296

; 4059 :       {
; 4060 :       int len;
; 4061 :       if (*tempcode == OP_EXACT || *tempcode == OP_TYPEEXACT ||
; 4062 :           *tempcode == OP_NOTEXACT)

	mov	al, BYTE PTR [ecx]
	cmp	al, 38					; 00000026H
	je	SHORT $LN812@compile_br
	cmp	al, 64					; 00000040H
	je	SHORT $LN760@compile_br
	cmp	al, 51					; 00000033H
	jne	SHORT $LN834@compile_br
$LN812@compile_br:

; 4063 :         tempcode += _pcre_OP_lengths[*tempcode] +
; 4064 :           ((*tempcode == OP_TYPEEXACT &&
; 4065 :              (tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP))? 2:0);

	cmp	al, 64					; 00000040H
	jne	SHORT $LN558@compile_br
$LN760@compile_br:
	mov	dl, BYTE PTR [ecx+3]
	cmp	dl, 15					; 0000000fH
	je	SHORT $LN557@compile_br
	cmp	dl, 14					; 0000000eH
	jne	SHORT $LN558@compile_br
$LN557@compile_br:
	mov	edx, 2
	jmp	SHORT $LN559@compile_br
$LN558@compile_br:
	xor	edx, edx
$LN559@compile_br:
	movzx	eax, al
	movzx	eax, BYTE PTR __pcre_OP_lengths[eax]
	add	eax, edx
	add	ecx, eax
	mov	DWORD PTR _tempcode$[esp+216], ecx
$LN834@compile_br:

; 4066 :       len = code - tempcode;

	mov	ebx, ebp
	sub	ebx, ecx

; 4067 :       if (len > 0) switch (*tempcode)

	test	ebx, ebx
	jle	$END_REPEAT$6296
	movzx	eax, BYTE PTR [ecx]
	add	eax, -30				; ffffffe2H
	cmp	eax, 32					; 00000020H
	ja	$LN221@compile_br
	movzx	edx, BYTE PTR $LN768@compile_br[eax]
	jmp	DWORD PTR $LN888@compile_br[edx*4]
$LN233@compile_br:

; 4068 :         {
; 4069 :         case OP_STAR:  *tempcode = OP_POSSTAR; break;

	mov	BYTE PTR [ecx], 39			; 00000027H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN232@compile_br:

; 4070 :         case OP_PLUS:  *tempcode = OP_POSPLUS; break;

	mov	BYTE PTR [ecx], 40			; 00000028H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN231@compile_br:

; 4071 :         case OP_QUERY: *tempcode = OP_POSQUERY; break;

	mov	BYTE PTR [ecx], 41			; 00000029H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN230@compile_br:

; 4072 :         case OP_UPTO:  *tempcode = OP_POSUPTO; break;

	mov	BYTE PTR [ecx], 42			; 0000002aH
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN229@compile_br:

; 4073 : 
; 4074 :         case OP_TYPESTAR:  *tempcode = OP_TYPEPOSSTAR; break;

	mov	BYTE PTR [ecx], 65			; 00000041H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN228@compile_br:

; 4075 :         case OP_TYPEPLUS:  *tempcode = OP_TYPEPOSPLUS; break;

	mov	BYTE PTR [ecx], 66			; 00000042H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN227@compile_br:

; 4076 :         case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;

	mov	BYTE PTR [ecx], 67			; 00000043H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	$END_REPEAT$6296
$LN226@compile_br:

; 4077 :         case OP_TYPEUPTO:  *tempcode = OP_TYPEPOSUPTO; break;

	mov	BYTE PTR [ecx], 68			; 00000044H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	SHORT $END_REPEAT$6296
$LN225@compile_br:

; 4078 : 
; 4079 :         case OP_NOTSTAR:  *tempcode = OP_NOTPOSSTAR; break;

	mov	BYTE PTR [ecx], 52			; 00000034H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	SHORT $END_REPEAT$6296
$LN224@compile_br:

; 4080 :         case OP_NOTPLUS:  *tempcode = OP_NOTPOSPLUS; break;

	mov	BYTE PTR [ecx], 53			; 00000035H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	SHORT $END_REPEAT$6296
$LN223@compile_br:

; 4081 :         case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;

	mov	BYTE PTR [ecx], 54			; 00000036H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	SHORT $END_REPEAT$6296
$LN222@compile_br:

; 4082 :         case OP_NOTUPTO:  *tempcode = OP_NOTPOSUPTO; break;

	mov	BYTE PTR [ecx], 55			; 00000037H
	mov	edi, DWORD PTR _ptr$[esp+216]
	jmp	SHORT $END_REPEAT$6296
$LN221@compile_br:

; 4083 : 
; 4084 :         default:
; 4085 :         memmove(tempcode + 1+LINK_SIZE, tempcode, len);

	push	ebx
	push	ecx
	add	ecx, 3
	push	ecx
	call	_memmove

; 4086 :         code += 1 + LINK_SIZE;
; 4087 :         len += 1 + LINK_SIZE;
; 4088 :         tempcode[0] = OP_ONCE;

	mov	eax, DWORD PTR _tempcode$[esp+228]
	mov	BYTE PTR [eax], 92			; 0000005cH

; 4089 :         *code++ = OP_KET;

	mov	BYTE PTR [ebp+3], 84			; 00000054H
	add	ebx, 3
	add	ebp, 3

; 4090 :         PUTINC(code, 0, len);

	mov	BYTE PTR [ebp+2], bl
	add	ebp, 1
	mov	eax, ebx
	sar	eax, 8
	mov	BYTE PTR [ebp], al

; 4091 :         PUT(tempcode, 1, len);

	mov	ecx, DWORD PTR _tempcode$[esp+228]
	mov	BYTE PTR [ecx+1], al
	mov	edx, DWORD PTR _tempcode$[esp+228]
	add	esp, 12					; 0000000cH
	add	ebp, 2
	mov	BYTE PTR [edx+2], bl
	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	DWORD PTR _code$[esp+216], ebp
	jmp	SHORT $END_REPEAT$6296
$LN875@compile_br:

; 3755 :         {
; 3756 :         code = previous;

	mov	DWORD PTR _code$[esp+216], esi
$LN813@compile_br:

; 3825 :           {
; 3826 :           code = previous;
; 3827 :           goto END_REPEAT;

	mov	ebp, DWORD PTR _code$[esp+216]
$END_REPEAT$6296:

; 4092 :         break;
; 4093 :         }
; 4094 :       }
; 4095 : 
; 4096 :     /* In all case we no longer have a previous item. We also set the
; 4097 :     "follows varying string" flag for subsequently encountered reqbytes if
; 4098 :     it isn't already set and we have just passed a varying length item. */
; 4099 : 
; 4100 :     END_REPEAT:
; 4101 :     previous = NULL;
; 4102 :     cd->req_varyopt |= reqvary;

	mov	ecx, DWORD PTR _reqvary$[esp+216]
	mov	eax, DWORD PTR _cd$[esp+212]
	or	DWORD PTR [eax+72], ecx
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	mov	DWORD PTR _previous$[esp+216], 0
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN220@compile_br:

; 4103 :     break;
; 4104 : 
; 4105 : 
; 4106 :     /* ===================================================================*/
; 4107 :     /* Start of nested parenthesized sub-expression, or comment or lookahead or
; 4108 :     lookbehind or option setting or condition or all the other extended
; 4109 :     parenthesis forms.  */
; 4110 : 
; 4111 :     case '(':
; 4112 :     newoptions = options;

	mov	edx, DWORD PTR _options$[esp+216]

; 4113 :     skipbytes = 0;
; 4114 :     bravalue = OP_CBRA;
; 4115 :     save_hwm = cd->hwm;

	mov	ecx, DWORD PTR [ebx+32]
	xor	eax, eax

; 4116 :     reset_bracount = FALSE;
; 4117 : 
; 4118 :     /* First deal with various "verbs" that can be introduced by '*'. */
; 4119 : 
; 4120 :     if (*(++ptr) == '*' && (cd->ctypes[ptr[1]] & ctype_letter) != 0)

	add	edi, 1
	mov	DWORD PTR _skipbytes$6016[esp+216], eax
	mov	DWORD PTR _reset_bracount$6010[esp+216], eax
	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	cmp	al, 42					; 0000002aH
	mov	DWORD PTR _newoptions$6013[esp+216], edx
	mov	DWORD PTR _bravalue$[esp+216], 94	; 0000005eH
	mov	DWORD PTR _save_hwm$[esp+216], ecx
	jne	$LN814@compile_br
	movzx	esi, BYTE PTR [edi+1]
	mov	ecx, DWORD PTR [ebx+12]
	test	BYTE PTR [esi+ecx], 2
	je	$LN814@compile_br
	add	edi, 1

; 4121 :       {
; 4122 :       int i, namelen;
; 4123 :       const char *vn = verbnames;

	mov	DWORD PTR _vn$6436[esp+216], OFFSET _verbnames

; 4124 :       const uschar *name = ++ptr;

	mov	DWORD PTR _name$6437[esp+216], edi

; 4125 :       previous = NULL;

	mov	DWORD PTR _previous$[esp+216], 0
	npad	6
$LL218@compile_br:

; 4126 :       while ((cd->ctypes[*++ptr] & ctype_letter) != 0);

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	edx, BYTE PTR [edi]
	test	BYTE PTR [edx+ecx], 2
	jne	SHORT $LL218@compile_br

; 4127 :       if (*ptr == ':')

	mov	al, BYTE PTR [edi]
	cmp	al, 58					; 0000003aH
	je	$LN687@compile_br

; 4130 :         goto FAILED;
; 4131 :         }
; 4132 :       if (*ptr != ')')

	cmp	al, 41					; 00000029H
	jne	$LN688@compile_br

; 4136 :         }
; 4137 :       namelen = ptr - name;

	mov	esi, edi
	sub	esi, DWORD PTR _name$6437[esp+216]

; 4138 :       for (i = 0; i < verbcount; i++)

	xor	ebx, ebx
	cmp	DWORD PTR _verbcount, ebx
	jle	SHORT $LN209@compile_br
$LL214@compile_br:

; 4139 :         {
; 4140 :         if (namelen == verbs[i].len &&
; 4141 :             strncmp((char *)name, vn, namelen) == 0)

	cmp	esi, DWORD PTR _verbs[ebx*8]
	jne	SHORT $LN847@compile_br
	mov	eax, DWORD PTR _vn$6436[esp+216]
	mov	ecx, DWORD PTR _name$6437[esp+216]
	push	esi
	push	eax
	push	ecx
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN670@compile_br
$LN847@compile_br:

; 4145 :           break;
; 4146 :           }
; 4147 :         vn += verbs[i].len + 1;

	mov	edx, DWORD PTR _verbs[ebx*8]
	mov	eax, DWORD PTR _vn$6436[esp+216]
	add	ebx, 1
	cmp	ebx, DWORD PTR _verbcount
	lea	ecx, DWORD PTR [eax+edx+1]
	mov	DWORD PTR _vn$6436[esp+216], ecx
	jl	SHORT $LL214@compile_br
$LN788@compile_br:

; 4135 :         goto FAILED;

	mov	edi, DWORD PTR _ptr$[esp+216]
$LN209@compile_br:

; 4150 :       *errorcodeptr = ERR60;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 60			; 0000003cH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN670@compile_br:

; 4142 :           {
; 4143 :           *code = verbs[i].op;

	mov	al, BYTE PTR _verbs[ebx*8+4]
	mov	BYTE PTR [ebp], al

; 4144 :           if (*code++ == OP_ACCEPT) cd->had_accept = TRUE;

	add	ebp, 1
	cmp	al, 109					; 0000006dH
	mov	DWORD PTR _code$[esp+216], ebp
	jne	SHORT $LN210@compile_br
	mov	edx, DWORD PTR _cd$[esp+212]
	mov	DWORD PTR [edx+76], 1
$LN210@compile_br:

; 4148 :         }
; 4149 :       if (i < verbcount) continue;

	cmp	ebx, DWORD PTR _verbcount
	jge	SHORT $LN788@compile_br
	jmp	$LN787@compile_br
$LN814@compile_br:

; 4151 :       goto FAILED;
; 4152 :       }
; 4153 : 
; 4154 :     /* Deal with the extended parentheses; all are introduced by '?', and the
; 4155 :     appearance of any of them means that this is not a capturing group. */
; 4156 : 
; 4157 :     else if (*ptr == '?')

	cmp	al, 63					; 0000003fH
	jne	$LN207@compile_br

; 4158 :       {
; 4159 :       int i, set, unset, namelen;
; 4160 :       int *optset;
; 4161 :       const uschar *name;
; 4162 :       uschar *slot;
; 4163 : 
; 4164 :       switch (*(++ptr))

	mov	esi, 1
	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	movzx	ecx, al
	add	ecx, -33				; ffffffdfH
	cmp	ecx, 91					; 0000005bH
	ja	$OTHER_CHAR_AFTER_QUERY$6602
	movzx	ecx, BYTE PTR $LN769@compile_br[ecx]
	jmp	DWORD PTR $LN889@compile_br[ecx*4]
$LN204@compile_br:

; 4165 :         {
; 4166 :         case '#':                 /* Comment; skip to ket */
; 4167 :         ptr++;

	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi

; 4168 :         while (*ptr != 0 && *ptr != ')') ptr++;

	mov	al, BYTE PTR [edi]
	test	al, al
	je	SHORT $LN689@compile_br
$LL203@compile_br:
	cmp	al, 41					; 00000029H
	je	SHORT $LN202@compile_br
	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	test	al, al
	jne	SHORT $LL203@compile_br
$LN689@compile_br:

; 4170 :           {
; 4171 :           *errorcodeptr = ERR18;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 18			; 00000012H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN202@compile_br:

; 4169 :         if (*ptr == 0)

	cmp	BYTE PTR [edi], 0
	je	SHORT $LN689@compile_br
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN200@compile_br:

; 4172 :           goto FAILED;
; 4173 :           }
; 4174 :         continue;
; 4175 : 
; 4176 : 
; 4177 :         /* ------------------------------------------------------------ */
; 4178 :         case '|':                 /* Reset capture count for each branch */
; 4179 :         reset_bracount = TRUE;

	mov	DWORD PTR _reset_bracount$6010[esp+216], esi
$LN199@compile_br:

; 4180 :         /* Fall through */
; 4181 : 
; 4182 :         /* ------------------------------------------------------------ */
; 4183 :         case ':':                 /* Non-capturing bracket */
; 4184 :         bravalue = OP_BRA;
; 4185 :         ptr++;

	add	edi, esi
	mov	DWORD PTR _bravalue$[esp+216], 93	; 0000005dH
	mov	DWORD PTR _ptr$[esp+216], edi

; 4186 :         break;

	jmp	$LN822@compile_br
$LN198@compile_br:

; 4187 : 
; 4188 : 
; 4189 :         /* ------------------------------------------------------------ */
; 4190 :         case '(':
; 4191 :         bravalue = OP_COND;       /* Conditional group */
; 4192 : 
; 4193 :         /* A condition can be an assertion, a number (referring to a numbered
; 4194 :         group), a name (referring to a named group), or 'R', referring to
; 4195 :         recursion. R<digits> and R&name are also permitted for recursion tests.
; 4196 : 
; 4197 :         There are several syntaxes for testing a named group: (?(name)) is used
; 4198 :         by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')).
; 4199 : 
; 4200 :         There are two unfortunate ambiguities, caused by history. (a) 'R' can
; 4201 :         be the recursive thing or the name 'R' (and similarly for 'R' followed
; 4202 :         by digits), and (b) a number could be a name that consists of digits.
; 4203 :         In both cases, we look for a name first; if not found, we try the other
; 4204 :         cases. */
; 4205 : 
; 4206 :         /* For conditions that are assertions, check the syntax, and then exit
; 4207 :         the switch. This will take control down to where bracketed groups,
; 4208 :         including assertions, are processed. */
; 4209 : 
; 4210 :         if (ptr[1] == '?' && (ptr[2] == '=' || ptr[2] == '!' || ptr[2] == '<'))

	cmp	BYTE PTR [edi+1], 63			; 0000003fH
	mov	DWORD PTR _bravalue$[esp+216], 95	; 0000005fH
	jne	SHORT $LN815@compile_br
	mov	al, BYTE PTR [edi+2]
	cmp	al, 61					; 0000003dH
	je	$LN822@compile_br
	cmp	al, 33					; 00000021H
	je	$LN822@compile_br
	cmp	al, 60					; 0000003cH

; 4211 :           break;

	je	$LN822@compile_br
$LN815@compile_br:

; 4212 : 
; 4213 :         /* Most other conditions use OP_CREF (a couple change to OP_RREF
; 4214 :         below), and all need to skip 3 bytes at the start of the group. */
; 4215 : 
; 4216 :         code[1+LINK_SIZE] = OP_CREF;

	mov	BYTE PTR [ebp+3], 99			; 00000063H

; 4217 :         skipbytes = 3;
; 4218 :         refsign = -1;
; 4219 : 
; 4220 :         /* Check for a test for recursion in a named group. */
; 4221 : 
; 4222 :         if (ptr[1] == 'R' && ptr[2] == '&')

	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	al, BYTE PTR [edi+1]
	or	esi, -1
	cmp	al, 82					; 00000052H
	mov	DWORD PTR _skipbytes$6016[esp+216], 3
	mov	DWORD PTR _refsign$6015[esp+216], esi
	jne	SHORT $LN195@compile_br
	cmp	BYTE PTR [edi+2], 38			; 00000026H
	lea	ecx, DWORD PTR [edi+2]
	jne	SHORT $LN195@compile_br

; 4223 :           {
; 4224 :           terminator = -1;
; 4225 :           ptr += 2;

	mov	DWORD PTR _ptr$[esp+216], ecx

; 4226 :           code[1+LINK_SIZE] = OP_RREF;    /* Change the type of test */

	mov	BYTE PTR [ebp+3], 100			; 00000064H
	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	DWORD PTR _terminator$6019[esp+216], esi
	jmp	SHORT $LN189@compile_br
$LN195@compile_br:

; 4227 :           }
; 4228 : 
; 4229 :         /* Check for a test for a named group's having been set, using the Perl
; 4230 :         syntax (?(<name>) or (?('name') */
; 4231 : 
; 4232 :         else if (ptr[1] == '<')

	cmp	al, 60					; 0000003cH
	jne	SHORT $LN193@compile_br
	add	edi, 1

; 4233 :           {
; 4234 :           terminator = '>';

	mov	DWORD PTR _terminator$6019[esp+216], 62	; 0000003eH

; 4235 :           ptr++;

	mov	DWORD PTR _ptr$[esp+216], edi
	jmp	SHORT $LN189@compile_br
$LN193@compile_br:

; 4236 :           }
; 4237 :         else if (ptr[1] == '\'')

	cmp	al, 39					; 00000027H
	jne	SHORT $LN191@compile_br
	add	edi, 1

; 4238 :           {
; 4239 :           terminator = '\'';

	mov	DWORD PTR _terminator$6019[esp+216], 39	; 00000027H

; 4240 :           ptr++;

	mov	DWORD PTR _ptr$[esp+216], edi

; 4241 :           }
; 4242 :         else

	jmp	SHORT $LN189@compile_br
$LN191@compile_br:

; 4243 :           {
; 4244 :           terminator = 0;
; 4245 :           if (ptr[1] == '-' || ptr[1] == '+') refsign = *(++ptr);

	cmp	al, 45					; 0000002dH
	mov	DWORD PTR _terminator$6019[esp+216], 0
	je	SHORT $LN188@compile_br
	cmp	al, 43					; 0000002bH
	jne	SHORT $LN189@compile_br
$LN188@compile_br:

; 4217 :         skipbytes = 3;
; 4218 :         refsign = -1;
; 4219 : 
; 4220 :         /* Check for a test for recursion in a named group. */
; 4221 : 
; 4222 :         if (ptr[1] == 'R' && ptr[2] == '&')

	add	edi, 1

; 4243 :           {
; 4244 :           terminator = 0;
; 4245 :           if (ptr[1] == '-' || ptr[1] == '+') refsign = *(++ptr);

	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	edx, BYTE PTR [edi]
	mov	DWORD PTR _refsign$6015[esp+216], edx
$LN189@compile_br:

; 4246 :           }
; 4247 : 
; 4248 :         /* We now expect to read a name; any thing else is an error */
; 4249 : 
; 4250 :         if ((cd->ctypes[ptr[1]] & ctype_word) == 0)

	movzx	eax, BYTE PTR [edi+1]
	mov	edx, DWORD PTR [ebx+12]
	add	edi, 1
	test	BYTE PTR [eax+edx], 16			; 00000010H
	je	$LN690@compile_br

; 4254 :           goto FAILED;
; 4255 :           }
; 4256 : 
; 4257 :         /* Read the name, but also get it as a number if it's all digits */
; 4258 : 
; 4259 :         recno = 0;
; 4260 :         name = ++ptr;

	mov	DWORD PTR _ptr$[esp+216], edi

; 4261 :         while ((cd->ctypes[*ptr] & ctype_word) != 0)

	movzx	eax, BYTE PTR [edi]
	xor	ecx, ecx
	test	BYTE PTR [edx+eax], 16			; 00000010H
	mov	DWORD PTR _recno$6014[esp+216], ecx
	mov	DWORD PTR _name$6458[esp+216], edi
	je	SHORT $LN185@compile_br
$LL186@compile_br:

; 4262 :           {
; 4263 :           if (recno >= 0)

	test	ecx, ecx
	jl	SHORT $LN561@compile_br

; 4264 :             recno = ((digitab[*ptr] & ctype_digit) != 0)?
; 4265 :               recno * 10 + *ptr - '0' : -1;

	test	BYTE PTR _digitab[eax], 4
	je	SHORT $LN560@compile_br
	lea	ecx, DWORD PTR [ecx+ecx*4]
	lea	eax, DWORD PTR [eax+ecx*2-48]
	mov	DWORD PTR _recno$6014[esp+216], eax
	jmp	SHORT $LN876@compile_br
$LN560@compile_br:
	mov	DWORD PTR _recno$6014[esp+216], esi
$LN876@compile_br:
	mov	ecx, DWORD PTR _recno$6014[esp+216]
$LN561@compile_br:

; 4266 :           ptr++;

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	eax, BYTE PTR [edi]
	test	BYTE PTR [eax+edx], 16			; 00000010H
	jne	SHORT $LL186@compile_br
$LN185@compile_br:

; 4267 :           }
; 4268 :         namelen = ptr - name;
; 4269 : 
; 4270 :         if ((terminator > 0 && *ptr++ != terminator) || *ptr++ != ')')

	mov	eax, DWORD PTR _terminator$6019[esp+216]
	mov	esi, edi
	sub	esi, DWORD PTR _name$6458[esp+216]
	test	eax, eax
	jle	SHORT $LN849@compile_br
	movzx	edx, BYTE PTR [edi]
	add	edi, 1
	cmp	edx, eax
	mov	DWORD PTR _ptr$[esp+216], edi
	jne	$LN182@compile_br
$LN849@compile_br:
	mov	al, BYTE PTR [edi]
	add	edi, 1
	cmp	al, 41					; 00000029H
	mov	DWORD PTR _ptr$[esp+216], edi
	jne	$LN182@compile_br

; 4274 :           goto FAILED;
; 4275 :           }
; 4276 : 
; 4277 :         /* Do no further checking in the pre-compile phase. */
; 4278 : 
; 4279 :         if (lengthptr != NULL) break;

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	jne	$LN821@compile_br

; 4280 : 
; 4281 :         /* In the real compile we do the work of looking for the actual
; 4282 :         reference. If the string started with "+" or "-" we require the rest to
; 4283 :         be digits, in which case recno will be set. */
; 4284 : 
; 4285 :         if (refsign > 0)

	mov	eax, DWORD PTR _refsign$6015[esp+216]
	test	eax, eax
	jle	SHORT $LN179@compile_br

; 4286 :           {
; 4287 :           if (recno <= 0)

	test	ecx, ecx
	jle	$LN691@compile_br

; 4290 :             goto FAILED;
; 4291 :             }
; 4292 :           recno = (refsign == '-')?
; 4293 :             cd->bracount - recno + 1 : recno +cd->bracount;

	cmp	eax, 45					; 0000002dH
	mov	eax, DWORD PTR _cd$[esp+212]
	jne	SHORT $LN562@compile_br
	mov	edx, DWORD PTR [eax+48]
	sub	edx, ecx
	add	edx, 1
	mov	DWORD PTR _recno$6014[esp+216], edx
	mov	ecx, edx
	jmp	SHORT $LN563@compile_br
$LN562@compile_br:
	add	ecx, DWORD PTR [eax+48]
$LN563@compile_br:

; 4294 :           if (recno <= 0 || recno > cd->final_bracount)

	test	ecx, ecx
	jle	$LN692@compile_br
	cmp	ecx, DWORD PTR [eax+52]
	jg	$LN692@compile_br

; 4297 :             goto FAILED;
; 4298 :             }
; 4299 :           PUT2(code, 2+LINK_SIZE, recno);

	mov	eax, ecx
	sar	eax, 8
	mov	BYTE PTR [ebp+4], al
	mov	BYTE PTR [ebp+5], cl

; 4300 :           break;

	jmp	$LN821@compile_br
$LN179@compile_br:

; 4301 :           }
; 4302 : 
; 4303 :         /* Otherwise (did not start with "+" or "-"), start by looking for the
; 4304 :         name. */
; 4305 : 
; 4306 :         slot = cd->name_table;

	mov	eax, DWORD PTR _cd$[esp+212]

; 4307 :         for (i = 0; i < cd->names_found; i++)

	cmp	DWORD PTR [eax+40], 0
	mov	ebx, DWORD PTR [eax+36]
	mov	DWORD PTR _i$6453[esp+216], 0
	jle	SHORT $LN671@compile_br
	mov	edi, DWORD PTR _i$6453[esp+216]
$LL175@compile_br:

; 4308 :           {
; 4309 :           if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;

	mov	edx, DWORD PTR _name$6458[esp+216]
	push	esi
	lea	ecx, DWORD PTR [ebx+2]
	push	ecx
	push	edx
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN779@compile_br

; 4310 :           slot += cd->name_entry_size;

	mov	eax, DWORD PTR _cd$[esp+212]
	add	ebx, DWORD PTR [eax+44]
	add	edi, 1
	cmp	edi, DWORD PTR [eax+40]
	mov	DWORD PTR _i$6453[esp+216], edi
	jl	SHORT $LL175@compile_br
$LN779@compile_br:

; 4307 :         for (i = 0; i < cd->names_found; i++)

	mov	edi, DWORD PTR _ptr$[esp+216]
$LN671@compile_br:

; 4311 :           }
; 4312 : 
; 4313 :         /* Found a previous named subpattern */
; 4314 : 
; 4315 :         if (i < cd->names_found)

	mov	eax, DWORD PTR _i$6453[esp+216]
	mov	ecx, DWORD PTR _cd$[esp+212]
	cmp	eax, DWORD PTR [ecx+40]
	jge	SHORT $LN171@compile_br

; 4316 :           {
; 4317 :           recno = GET2(slot, 0);

	movzx	eax, BYTE PTR [ebx+1]
	mov	ah, BYTE PTR [ebx]

; 4318 :           PUT2(code, 2+LINK_SIZE, recno);

	mov	BYTE PTR [ebp+5], al

; 4319 :           }
; 4320 : 
; 4321 :         /* Search the pattern for a forward reference */
; 4322 : 
; 4323 :         else if ((i = find_parens(ptr, cd->bracount, name, namelen,

	mov	ebx, ecx
	mov	edx, eax
	sar	edx, 8
	mov	BYTE PTR [ebp+4], dl
	jmp	SHORT $LN822@compile_br
$LN171@compile_br:

; 4324 :                         (options & PCRE_EXTENDED) != 0)) > 0)

	mov	eax, DWORD PTR _options$[esp+216]
	mov	ebx, DWORD PTR _name$6458[esp+216]
	shr	eax, 3
	and	eax, 1
	push	eax
	mov	ebp, ecx
	mov	eax, DWORD PTR [ebp+48]
	push	esi
	mov	ecx, edi
	call	_find_parens
	add	esp, 8
	test	eax, eax
	jle	$LN169@compile_br
$LN879@compile_br:

; 4325 :           {
; 4326 :           PUT2(code, 2+LINK_SIZE, i);

	mov	ecx, DWORD PTR _code$[esp+216]
	mov	edx, eax
	sar	edx, 8
	mov	BYTE PTR [ecx+4], dl
	mov	BYTE PTR [ecx+5], al
$LN880@compile_br:

; 4358 :           PUT2(code, 2+LINK_SIZE, recno);

	mov	ebp, DWORD PTR _code$[esp+216]
$LN821@compile_br:

; 4435 :         break;

	mov	ebx, DWORD PTR _cd$[esp+212]
$LN822@compile_br:

; 4883 :       }
; 4884 : 
; 4885 :     /* Process nested bracketed regex. Assertions may not be repeated, but
; 4886 :     other kinds can be. All their opcodes are >= OP_ONCE. We copy code into a
; 4887 :     non-register variable in order to be able to pass its address because some
; 4888 :     compilers complain otherwise. Pass in a new setting for the ims options if
; 4889 :     they have changed. */
; 4890 : 
; 4891 :     previous = (bravalue >= OP_ONCE)? code : NULL;

	mov	ecx, DWORD PTR _bravalue$[esp+216]
	xor	eax, eax
	cmp	ecx, 92					; 0000005cH
	setl	al

; 4892 :     *code = bravalue;

	mov	BYTE PTR [ebp], cl

; 4893 :     tempcode = code;
; 4894 :     tempreqvary = cd->req_varyopt;     /* Save value before bracket */

	mov	edx, DWORD PTR [ebx+72]
	mov	DWORD PTR _tempcode$[esp+216], ebp
	mov	DWORD PTR _tempreqvary$[esp+216], edx
	sub	eax, 1
	and	eax, ebp
	mov	DWORD PTR _previous$[esp+216], eax

; 4895 :     length_prevgroup = 0;              /* Initialize for pre-compile phase */

	xor	eax, eax

; 4896 : 
; 4897 :     if (!compile_regex(
; 4898 :          newoptions,                   /* The complete new option state */
; 4899 :          options & PCRE_IMS,           /* The previous ims option state */
; 4900 :          &tempcode,                    /* Where to put code (updated) */
; 4901 :          &ptr,                         /* Input pointer (updated) */
; 4902 :          errorcodeptr,                 /* Where to put an error message */
; 4903 :          (bravalue == OP_ASSERTBACK ||
; 4904 :           bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
; 4905 :          reset_bracount,               /* True if (?| group */
; 4906 :          skipbytes,                    /* Skip over bracket number */
; 4907 :          &subfirstbyte,                /* For possible first char */
; 4908 :          &subreqbyte,                  /* For possible last char */
; 4909 :          bcptr,                        /* Current branch chain */
; 4910 :          cd,                           /* Tables block */
; 4911 :          (lengthptr == NULL)? NULL :   /* Actual compile phase */
; 4912 :            &length_prevgroup           /* Pre-compile phase */
; 4913 :          ))

	cmp	ecx, 89					; 00000059H
	mov	DWORD PTR _length_prevgroup$[esp+216], eax
	je	SHORT $LN564@compile_br
	cmp	ecx, 90					; 0000005aH
	jne	SHORT $LN565@compile_br
$LN564@compile_br:
	mov	eax, 1
$LN565@compile_br:
	mov	edi, DWORD PTR _lengthptr$[esp+212]
	mov	ecx, edi
	neg	ecx
	sbb	ecx, ecx
	lea	edx, DWORD PTR _length_prevgroup$[esp+216]
	and	ecx, edx
	push	ecx
	mov	ecx, DWORD PTR _bcptr$[esp+216]
	push	ebx
	mov	ebx, DWORD PTR _errorcodeptr$[esp+220]
	push	ecx
	lea	edx, DWORD PTR _subreqbyte$6017[esp+228]
	push	edx
	mov	edx, DWORD PTR _skipbytes$6016[esp+232]
	lea	ecx, DWORD PTR _subfirstbyte$6018[esp+232]
	push	ecx
	mov	ecx, DWORD PTR _reset_bracount$6010[esp+236]
	push	edx
	push	ecx
	mov	ecx, DWORD PTR _options$[esp+244]
	push	eax
	push	ebx
	lea	edx, DWORD PTR _ptr$[esp+252]
	push	edx
	mov	edx, DWORD PTR _newoptions$6013[esp+256]
	lea	eax, DWORD PTR _tempcode$[esp+256]
	push	eax
	and	ecx, 7
	push	ecx
	push	edx
	call	_compile_regex
	add	esp, 52					; 00000034H
	test	eax, eax
	je	$LN789@compile_br

; 4914 :       goto FAILED;
; 4915 : 
; 4916 :     /* At the end of compiling, code is still pointing to the start of the
; 4917 :     group, while tempcode has been updated to point past the end of the group
; 4918 :     and any option resetting that may follow it. The pattern pointer (ptr)
; 4919 :     is on the bracket. */
; 4920 : 
; 4921 :     /* If this is a conditional bracket, check that there are no more than
; 4922 :     two branches in the group, or just one if it's a DEFINE group. We do this
; 4923 :     in the real compile phase, not in the pre-pass, where the whole group may
; 4924 :     not be available. */
; 4925 : 
; 4926 :     if (bravalue == OP_COND && lengthptr == NULL)

	mov	esi, DWORD PTR _bravalue$[esp+216]
	cmp	esi, 95					; 0000005fH
	jne	SHORT $LN781@compile_br
	test	edi, edi
	jne	SHORT $LN781@compile_br

; 4927 :       {
; 4928 :       uschar *tc = code;

	mov	eax, ebp

; 4929 :       int condcount = 0;

	xor	ecx, ecx
	npad	2
$LL52@compile_br:

; 4930 : 
; 4931 :       do {
; 4932 :          condcount++;
; 4933 :          tc += GET(tc,1);

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

; 4934 :          }
; 4935 :       while (*tc != OP_KET);

	cmp	BYTE PTR [eax], 84			; 00000054H
	jne	SHORT $LL52@compile_br

; 4936 : 
; 4937 :       /* A DEFINE group is never obeyed inline (the "condition" is always
; 4938 :       false). It must have only one branch. */
; 4939 : 
; 4940 :       if (code[LINK_SIZE+1] == OP_DEF)

	cmp	BYTE PTR [ebp+3], 101			; 00000065H
	jne	$LN49@compile_br

; 4941 :         {
; 4942 :         if (condcount > 1)

	cmp	ecx, 1
	jg	$LN706@compile_br

; 4946 :           }
; 4947 :         bravalue = OP_DEF;   /* Just a flag to suppress char handling below */

	mov	DWORD PTR _bravalue$[esp+216], 101	; 00000065H

; 4948 :         }
; 4949 : 
; 4950 :       /* A "normal" conditional group. If there is just one branch, we must not
; 4951 :       make use of its firstbyte or reqbyte, because this is equivalent to an
; 4952 :       empty second branch. */
; 4953 : 
; 4954 :       else

	mov	esi, DWORD PTR _bravalue$[esp+216]
$LN781@compile_br:

; 4960 :           }
; 4961 :         if (condcount == 1) subfirstbyte = subreqbyte = REQ_NONE;

	mov	eax, DWORD PTR _subfirstbyte$6018[esp+216]
	mov	edx, DWORD PTR _subreqbyte$6017[esp+216]
$LN45@compile_br:

; 4962 :         }
; 4963 :       }
; 4964 : 
; 4965 :     /* Error if hit end of pattern */
; 4966 : 
; 4967 :     if (*ptr != ')')

	mov	edi, DWORD PTR _ptr$[esp+216]
	cmp	BYTE PTR [edi], 41			; 00000029H
	jne	$LN708@compile_br

; 4968 :       {
; 4969 :       *errorcodeptr = ERR14;
; 4970 :       goto FAILED;
; 4971 :       }
; 4972 : 
; 4973 :     /* In the pre-compile phase, update the length by the length of the group,
; 4974 :     less the brackets at either end. Then reduce the compiled code to just a
; 4975 :     set of non-capturing brackets so that it doesn't use much memory if it is
; 4976 :     duplicated by a quantifier.*/
; 4977 : 
; 4978 :     if (lengthptr != NULL)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	je	$LN43@compile_br

; 4979 :       {
; 4980 :       if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)

	mov	eax, DWORD PTR _lengthptr$[esp+212]
	mov	eax, DWORD PTR [eax]
	mov	ecx, DWORD PTR _length_prevgroup$[esp+216]
	mov	edx, 2147483627				; 7fffffebH
	sub	edx, eax
	lea	esi, DWORD PTR [ecx-6]
	cmp	edx, esi
	jl	$LN709@compile_br

; 4981 :         {
; 4982 :         *errorcodeptr = ERR20;
; 4983 :         goto FAILED;
; 4984 :         }
; 4985 :       *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;

	lea	eax, DWORD PTR [eax+ecx-6]
	mov	ecx, DWORD PTR _lengthptr$[esp+212]
	mov	DWORD PTR [ecx], eax

; 4986 :       *code++ = OP_BRA;

	mov	BYTE PTR [ebp], 93			; 0000005dH
	add	ebp, 1

; 4987 :       PUTINC(code, 0, 1 + LINK_SIZE);

	mov	BYTE PTR [ebp], 0
	mov	BYTE PTR [ebp+1], 3
	add	ebp, 2

; 4988 :       *code++ = OP_KET;

	mov	BYTE PTR [ebp], 84			; 00000054H
	add	ebp, 1

; 4989 :       PUTINC(code, 0, 1 + LINK_SIZE);

	mov	BYTE PTR [ebp], 0
	mov	BYTE PTR [ebp+1], 3
	add	ebp, 2

; 4990 :       break;    /* No need to waste time with special character handling */

	jmp	$LN884@compile_br
$LN169@compile_br:

; 4327 :           }
; 4328 : 
; 4329 :         /* If terminator == 0 it means that the name followed directly after
; 4330 :         the opening parenthesis [e.g. (?(abc)...] and in this case there are
; 4331 :         some further alternatives to try. For the cases where terminator != 0
; 4332 :         [things like (?(<name>... or (?('name')... or (?(R&name)... ] we have
; 4333 :         now checked all the possibilities, so give an error. */
; 4334 : 
; 4335 :         else if (terminator != 0)

	cmp	DWORD PTR _terminator$6019[esp+216], 0
	jne	$LN693@compile_br

; 4338 :           goto FAILED;
; 4339 :           }
; 4340 : 
; 4341 :         /* Check for (?(R) for recursion. Allow digits after R to specify a
; 4342 :         specific group number. */
; 4343 : 
; 4344 :         else if (*name == 'R')

	cmp	BYTE PTR [ebx], 82			; 00000052H
	jne	SHORT $LN165@compile_br

; 4345 :           {
; 4346 :           recno = 0;

	xor	ecx, ecx

; 4347 :           for (i = 1; i < namelen; i++)

	lea	eax, DWORD PTR [ecx+1]
	cmp	esi, eax
	jle	SHORT $LN761@compile_br
	npad	8
$LL164@compile_br:

; 4348 :             {
; 4349 :             if ((digitab[name[i]] & ctype_digit) == 0)

	movzx	edx, BYTE PTR [eax+ebx]
	test	BYTE PTR _digitab[edx], 4
	je	$LN672@compile_br
	add	eax, 1
	cmp	eax, esi

; 4353 :               }
; 4354 :             recno = recno * 10 + name[i] - '0';

	lea	ecx, DWORD PTR [ecx+ecx*4]
	lea	ecx, DWORD PTR [edx+ecx*2-48]
	jl	SHORT $LL164@compile_br

; 4355 :             }
; 4356 :           if (recno == 0) recno = RREF_ANY;

	test	ecx, ecx
	jne	SHORT $LN160@compile_br
$LN761@compile_br:
	mov	ecx, 65535				; 0000ffffH
$LN160@compile_br:

; 4357 :           code[1+LINK_SIZE] = OP_RREF;      /* Change test type */

	mov	eax, DWORD PTR _code$[esp+216]

; 4358 :           PUT2(code, 2+LINK_SIZE, recno);

	mov	edx, ecx
	sar	edx, 8
	mov	BYTE PTR [eax+3], 100			; 00000064H
	mov	BYTE PTR [eax+4], dl
	mov	BYTE PTR [eax+5], cl
	jmp	$LN880@compile_br
$LN165@compile_br:

; 4359 :           }
; 4360 : 
; 4361 :         /* Similarly, check for the (?(DEFINE) "condition", which is always
; 4362 :         false. */
; 4363 : 
; 4364 :         else if (namelen == 6 && strncmp((char *)name, "DEFINE", 6) == 0)

	cmp	esi, 6
	jne	SHORT $LN158@compile_br
	push	esi
	push	OFFSET ??_C@_06ELOHELOA@DEFINE?$AA@
	push	ebx
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN158@compile_br

; 4365 :           {
; 4366 :           code[1+LINK_SIZE] = OP_DEF;

	mov	eax, DWORD PTR _code$[esp+216]
	mov	BYTE PTR [eax+3], 101			; 00000065H

; 4367 :           skipbytes = 1;

	mov	DWORD PTR _skipbytes$6016[esp+216], 1
	jmp	$LN880@compile_br
$LN158@compile_br:

; 4368 :           }
; 4369 : 
; 4370 :         /* Check for the "name" actually being a subpattern number. We are
; 4371 :         in the second pass here, so final_bracount is set. */
; 4372 : 
; 4373 :         else if (recno > 0 && recno <= cd->final_bracount)

	mov	eax, DWORD PTR _recno$6014[esp+216]
	test	eax, eax
	jle	SHORT $LN156@compile_br
	cmp	eax, DWORD PTR [ebp+52]
	jle	$LN879@compile_br
$LN156@compile_br:

; 4374 :           {
; 4375 :           PUT2(code, 2+LINK_SIZE, recno);
; 4376 :           }
; 4377 : 
; 4378 :         /* Either an unidentified subpattern, or a reference to (?(0) */
; 4379 : 
; 4380 :         else
; 4381 :           {
; 4382 :           *errorcodeptr = (recno == 0)? ERR35: ERR15;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	neg	eax
	sbb	eax, eax
	and	eax, -20				; ffffffecH
	add	eax, 35					; 00000023H
	mov	DWORD PTR [ecx], eax
$LN789@compile_br:

; 4959 :           goto FAILED;

	mov	edi, DWORD PTR _ptr$[esp+216]
$FAILED$6025:

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN154@compile_br:

; 4383 :           goto FAILED;
; 4384 :           }
; 4385 :         break;
; 4386 : 
; 4387 : 
; 4388 :         /* ------------------------------------------------------------ */
; 4389 :         case '=':                 /* Positive lookahead */
; 4390 :         bravalue = OP_ASSERT;
; 4391 :         ptr++;

	add	edi, esi
	mov	DWORD PTR _bravalue$[esp+216], 87	; 00000057H
	mov	DWORD PTR _ptr$[esp+216], edi

; 4392 :         break;

	jmp	$LN822@compile_br
$LN153@compile_br:

; 4393 : 
; 4394 : 
; 4395 :         /* ------------------------------------------------------------ */
; 4396 :         case '!':                 /* Negative lookahead */
; 4397 :         ptr++;

	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi

; 4398 :         if (*ptr == ')')          /* Optimize (?!) */

	cmp	BYTE PTR [edi], 41			; 00000029H
	jne	SHORT $LN152@compile_br

; 4399 :           {
; 4400 :           *code++ = OP_FAIL;

	mov	BYTE PTR [ebp], 108			; 0000006cH
	add	ebp, esi

; 4401 :           previous = NULL;

	mov	DWORD PTR _previous$[esp+216], 0

; 4402 :           continue;

	jmp	$LN884@compile_br
$LN152@compile_br:

; 4403 :           }
; 4404 :         bravalue = OP_ASSERT_NOT;

	mov	DWORD PTR _bravalue$[esp+216], 88	; 00000058H

; 4405 :         break;

	jmp	$LN822@compile_br
$LN151@compile_br:

; 4406 : 
; 4407 : 
; 4408 :         /* ------------------------------------------------------------ */
; 4409 :         case '<':                 /* Lookbehind or named define */
; 4410 :         switch (ptr[1])

	mov	cl, BYTE PTR [edi+1]
	cmp	cl, 33					; 00000021H
	je	$LN147@compile_br
	cmp	cl, 61					; 0000003dH
	je	$LN148@compile_br

; 4420 :           break;
; 4421 : 
; 4422 :           default:                /* Could be name define, else bad */
; 4423 :           if ((cd->ctypes[ptr[1]] & ctype_word) != 0) goto DEFINE_NAME;

	mov	edx, DWORD PTR [ebx+12]
	movzx	ecx, cl
	test	BYTE PTR [ecx+edx], 16			; 00000010H
	je	$LN145@compile_br
$DEFINE_NAME$6534:

; 4477 :           goto FAILED;
; 4478 :           }
; 4479 :         /* Fall through to handle (?P< as (?< is handled */
; 4480 : 
; 4481 : 
; 4482 :         /* ------------------------------------------------------------ */
; 4483 :         DEFINE_NAME:    /* Come here from (?< handling */
; 4484 :         case '\'':
; 4485 :           {
; 4486 :           terminator = (*ptr == '<')? '>' : '\'';
; 4487 :           name = ++ptr;
; 4488 : 
; 4489 :           while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;

	mov	ecx, DWORD PTR [ebx+12]
	sub	al, 60					; 0000003cH
	neg	al
	sbb	eax, eax
	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	edx, BYTE PTR [edi]
	and	eax, -23				; ffffffe9H
	add	eax, 62					; 0000003eH
	test	BYTE PTR [edx+ecx], 16			; 00000010H
	mov	DWORD PTR _name$6458[esp+216], edi
	je	SHORT $LN131@compile_br
$LL132@compile_br:
	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	edx, BYTE PTR [edi]
	test	BYTE PTR [edx+ecx], 16			; 00000010H
	jne	SHORT $LL132@compile_br
$LN131@compile_br:

; 4490 :           namelen = ptr - name;

	mov	ebx, edi
	sub	ebx, DWORD PTR _name$6458[esp+216]

; 4491 : 
; 4492 :           /* In the pre-compile phase, just do a syntax check. */
; 4493 : 
; 4494 :           if (lengthptr != NULL)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	mov	DWORD PTR _namelen$6456[esp+216], ebx
	je	$LN130@compile_br

; 4495 :             {
; 4496 :             if (*ptr != terminator)

	movzx	ecx, BYTE PTR [edi]
	cmp	ecx, eax
	jne	$LN697@compile_br

; 4499 :               goto FAILED;
; 4500 :               }
; 4501 :             if (cd->names_found >= MAX_NAME_COUNT)

	mov	eax, DWORD PTR _cd$[esp+212]
	cmp	DWORD PTR [eax+40], 10000		; 00002710H
	jge	$LN698@compile_br

; 4504 :               goto FAILED;
; 4505 :               }
; 4506 :             if (namelen + 3 > cd->name_entry_size)

	lea	ecx, DWORD PTR [ebx+3]
	cmp	ecx, DWORD PTR [eax+44]
	jle	$LN125@compile_br

; 4507 :               {
; 4508 :               cd->name_entry_size = namelen + 3;
; 4509 :               if (namelen > MAX_NAME_SIZE)

	cmp	ebx, 32					; 00000020H
	mov	DWORD PTR [eax+44], ecx
	jle	$LN125@compile_br

; 4510 :                 {
; 4511 :                 *errorcodeptr = ERR48;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 48			; 00000030H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN148@compile_br:

; 4411 :           {
; 4412 :           case '=':               /* Positive lookbehind */
; 4413 :           bravalue = OP_ASSERTBACK;
; 4414 :           ptr += 2;

	add	edi, 2
	mov	DWORD PTR _bravalue$[esp+216], 89	; 00000059H
	mov	DWORD PTR _ptr$[esp+216], edi

; 4415 :           break;

	jmp	$LN822@compile_br
$LN147@compile_br:

; 4416 : 
; 4417 :           case '!':               /* Negative lookbehind */
; 4418 :           bravalue = OP_ASSERTBACK_NOT;
; 4419 :           ptr += 2;

	add	edi, 2
	mov	DWORD PTR _bravalue$[esp+216], 90	; 0000005aH
	mov	DWORD PTR _ptr$[esp+216], edi

; 4426 :           goto FAILED;
; 4427 :           }
; 4428 :         break;

	jmp	$LN822@compile_br
$LN144@compile_br:

; 4429 : 
; 4430 : 
; 4431 :         /* ------------------------------------------------------------ */
; 4432 :         case '>':                 /* One-time brackets */
; 4433 :         bravalue = OP_ONCE;
; 4434 :         ptr++;

	add	edi, esi
	mov	DWORD PTR _bravalue$[esp+216], 92	; 0000005cH
	mov	DWORD PTR _ptr$[esp+216], edi

; 4435 :         break;

	jmp	$LN822@compile_br
$LN143@compile_br:

; 4436 : 
; 4437 : 
; 4438 :         /* ------------------------------------------------------------ */
; 4439 :         case 'C':                 /* Callout - may be followed by digits; */
; 4440 :         previous_callout = code;  /* Save for later completion */
; 4441 :         after_manual_callout = 1; /* Skip one item before completing */
; 4442 :         *code++ = OP_CALLOUT;

	mov	BYTE PTR [ebp], 82			; 00000052H

; 4443 :           {
; 4444 :           int n = 0;
; 4445 :           while ((digitab[*(++ptr)] & ctype_digit) != 0)

	mov	edi, DWORD PTR _ptr$[esp+216]
	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	ecx, BYTE PTR [edi]
	mov	DWORD PTR _previous_callout$[esp+216], ebp
	mov	edx, 4
	add	ebp, esi
	xor	eax, eax
	test	BYTE PTR _digitab[ecx], dl
	mov	DWORD PTR _after_manual_callout$[esp+216], esi
	je	SHORT $LN141@compile_br
	npad	7
$LL142@compile_br:
	add	edi, esi

; 4446 :             n = n * 10 + *ptr - '0';

	lea	eax, DWORD PTR [eax+eax*4]
	lea	eax, DWORD PTR [ecx+eax*2-48]
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	ecx, BYTE PTR [edi]
	test	BYTE PTR _digitab[ecx], dl
	jne	SHORT $LL142@compile_br
$LN141@compile_br:

; 4447 :           if (*ptr != ')')

	cmp	BYTE PTR [edi], 41			; 00000029H
	jne	$LN694@compile_br

; 4450 :             goto FAILED;
; 4451 :             }
; 4452 :           if (n > 255)

	cmp	eax, 255				; 000000ffH
	jg	$LN695@compile_br

; 4455 :             goto FAILED;
; 4456 :             }
; 4457 :           *code++ = n;

	mov	BYTE PTR [ebp], al

; 4458 :           PUT(code, 0, ptr - cd->start_pattern + 1);  /* Pattern offset */

	mov	ecx, DWORD PTR _ptr$[esp+216]
	sub	ecx, DWORD PTR [ebx+24]
	add	ebp, esi
	add	ecx, esi
	sar	ecx, 8
	mov	BYTE PTR [ebp], cl
	mov	al, BYTE PTR _ptr$[esp+216]
	sub	al, BYTE PTR [ebx+24]

; 4459 :           PUT(code, LINK_SIZE, 0);                    /* Default length */

	mov	BYTE PTR [ebp+2], 0
	add	al, 1
	mov	BYTE PTR [ebp+1], al
	mov	BYTE PTR [ebp+3], 0

; 4460 :           code += 2 * LINK_SIZE;

	add	ebp, edx

; 4461 :           }
; 4462 :         previous = NULL;

	mov	DWORD PTR _previous$[esp+216], 0

; 4463 :         continue;

	jmp	$LN884@compile_br
$LN138@compile_br:

; 4464 : 
; 4465 : 
; 4466 :         /* ------------------------------------------------------------ */
; 4467 :         case 'P':                 /* Python-style named subpattern handling */
; 4468 :         if (*(++ptr) == '=' || *ptr == '>')  /* Reference or recursion */

	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	cmp	al, 61					; 0000003dH
	je	SHORT $LN816@compile_br
	cmp	al, 62					; 0000003eH
	je	SHORT $LN816@compile_br

; 4472 :           goto NAMED_REF_OR_RECURSE;
; 4473 :           }
; 4474 :         else if (*ptr != '<')    /* Test for Python-style definition */

	cmp	al, 60					; 0000003cH
	je	$DEFINE_NAME$6534

; 4475 :           {
; 4476 :           *errorcodeptr = ERR41;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 41			; 00000029H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN816@compile_br:

; 4469 :           {
; 4470 :           is_recurse = *ptr == '>';

	xor	ecx, ecx
	cmp	al, 62					; 0000003eH
	sete	cl

; 4471 :           terminator = ')';

	mov	eax, 41					; 00000029H
	mov	DWORD PTR _is_recurse$6009[esp+216], ecx
	jmp	$NAMED_REF_OR_RECURSE$6547
$LN130@compile_br:

; 4512 :                 goto FAILED;
; 4513 :                 }
; 4514 :               }
; 4515 :             }
; 4516 : 
; 4517 :           /* In the real compile, create the entry in the table */
; 4518 : 
; 4519 :           else
; 4520 :             {
; 4521 :             slot = cd->name_table;

	mov	eax, DWORD PTR _cd$[esp+212]
	mov	esi, DWORD PTR [eax+36]

; 4522 :             for (i = 0; i < cd->names_found; i++)

	mov	eax, DWORD PTR [eax+40]
	test	eax, eax
	mov	DWORD PTR _slot$6459[esp+216], esi
	mov	DWORD PTR _i$6453[esp+216], 0
	mov	DWORD PTR tv3622[esp+216], eax
	jle	$LN845@compile_br
	npad	8
$LL124@compile_br:

; 4523 :               {
; 4524 :               int crc = memcmp(name, slot+2, namelen);

	cmp	ebx, 4
	mov	edx, DWORD PTR _name$6458[esp+216]
	mov	eax, ebx
	lea	ecx, DWORD PTR [esi+2]
	jb	SHORT $LN673@compile_br
	npad	2
$LL573@compile_br:
	mov	ebx, DWORD PTR [edx]
	cmp	ebx, DWORD PTR [ecx]
	jne	SHORT $LN574@compile_br
	sub	eax, 4
	add	ecx, 4
	add	edx, 4
	cmp	eax, 4
	jae	SHORT $LL573@compile_br
	mov	ebx, DWORD PTR _namelen$6456[esp+216]
$LN673@compile_br:
	test	eax, eax
	je	SHORT $LN842@compile_br
$LN574@compile_br:
	movzx	esi, BYTE PTR [edx]
	movzx	ebx, BYTE PTR [ecx]
	sub	esi, ebx
	jne	SHORT $LN836@compile_br
	sub	eax, 1
	add	ecx, 1
	add	edx, 1
	test	eax, eax
	je	SHORT $LN841@compile_br
	movzx	esi, BYTE PTR [edx]
	movzx	ebx, BYTE PTR [ecx]
	sub	esi, ebx
	jne	SHORT $LN836@compile_br
	sub	eax, 1
	add	ecx, 1
	add	edx, 1
	test	eax, eax
	je	SHORT $LN841@compile_br
	movzx	esi, BYTE PTR [edx]
	movzx	ebx, BYTE PTR [ecx]
	sub	esi, ebx
	jne	SHORT $LN836@compile_br
	sub	eax, 1
	add	ecx, 1
	add	edx, 1
	test	eax, eax
	je	SHORT $LN841@compile_br
	movzx	esi, BYTE PTR [edx]
	movzx	edx, BYTE PTR [ecx]
	sub	esi, edx
	je	SHORT $LN841@compile_br
$LN836@compile_br:
	mov	ebx, DWORD PTR _namelen$6456[esp+216]
	test	esi, esi
	mov	esi, DWORD PTR _slot$6459[esp+216]
	mov	eax, 1
	jg	SHORT $LN577@compile_br
	or	eax, -1
	jmp	SHORT $LN577@compile_br
$LN841@compile_br:
	mov	esi, DWORD PTR _slot$6459[esp+216]
	mov	ebx, DWORD PTR _namelen$6456[esp+216]
$LN842@compile_br:
	xor	eax, eax
$LN577@compile_br:

; 4525 :               if (crc == 0)

	test	eax, eax
	jne	SHORT $LN877@compile_br

; 4526 :                 {
; 4527 :                 if (slot[2+namelen] == 0)

	cmp	BYTE PTR [esi+ebx+2], al
	jne	SHORT $LN675@compile_br

; 4528 :                   {
; 4529 :                   if ((options & PCRE_DUPNAMES) == 0)

	test	DWORD PTR _options$[esp+216], 524288	; 00080000H
	jne	SHORT $LN762@compile_br

; 4530 :                     {
; 4531 :                     *errorcodeptr = ERR43;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 43			; 0000002bH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN877@compile_br:

; 4532 :                     goto FAILED;
; 4533 :                     }
; 4534 :                   }
; 4535 :                 else crc = -1;      /* Current name is substring */
; 4536 :                 }
; 4537 :               if (crc < 0)

	jl	SHORT $LN675@compile_br
$LN762@compile_br:

; 4541 :                 break;
; 4542 :                 }
; 4543 :               slot += cd->name_entry_size;

	mov	ecx, DWORD PTR _cd$[esp+212]
	mov	eax, DWORD PTR _i$6453[esp+216]
	add	esi, DWORD PTR [ecx+44]
	add	eax, 1
	cmp	eax, DWORD PTR [ecx+40]
	mov	DWORD PTR _slot$6459[esp+216], esi
	mov	DWORD PTR _i$6453[esp+216], eax
	jl	$LL124@compile_br

; 4522 :             for (i = 0; i < cd->names_found; i++)

	jmp	SHORT $LN845@compile_br
$LN675@compile_br:

; 4538 :                 {
; 4539 :                 memmove(slot + cd->name_entry_size, slot,
; 4540 :                   (cd->names_found - i) * cd->name_entry_size);

	mov	ecx, DWORD PTR tv3622[esp+216]
	sub	ecx, DWORD PTR _i$6453[esp+216]
	mov	eax, DWORD PTR _cd$[esp+212]
	mov	eax, DWORD PTR [eax+44]
	imul	ecx, eax
	push	ecx
	lea	ecx, DWORD PTR [esi+eax]
	push	esi
	push	ecx
	call	_memmove
	add	esp, 12					; 0000000cH
$LN845@compile_br:

; 4544 :               }
; 4545 : 
; 4546 :             PUT2(slot, 0, cd->bracount + 1);

	mov	eax, DWORD PTR _cd$[esp+212]
	mov	edx, DWORD PTR [eax+48]

; 4547 :             memcpy(slot + 2, name, namelen);

	mov	ecx, DWORD PTR _name$6458[esp+216]
	add	edx, 1
	sar	edx, 8
	mov	BYTE PTR [esi], dl
	mov	al, BYTE PTR [eax+48]
	push	ebx
	push	ecx
	lea	edx, DWORD PTR [esi+2]
	add	al, 1
	push	edx
	mov	BYTE PTR [esi+1], al
	call	_memcpy

; 4548 :             slot[2+namelen] = 0;

	mov	eax, DWORD PTR _cd$[esp+224]
	mov	BYTE PTR [esi+ebx+2], 0
	mov	edi, DWORD PTR _ptr$[esp+228]
	add	esp, 12					; 0000000cH
$LN125@compile_br:

; 4549 :             }
; 4550 :           }
; 4551 : 
; 4552 :         /* In both cases, count the number of names we've encountered. */
; 4553 : 
; 4554 :         ptr++;                    /* Move past > or ' */

	add	edi, 1

; 4555 :         cd->names_found++;

	add	DWORD PTR [eax+40], 1
	mov	DWORD PTR _ptr$[esp+216], edi
$NUMBERED_GROUP$6570:

; 4878 :       {
; 4879 :       NUMBERED_GROUP:
; 4880 :       cd->bracount += 1;

	mov	eax, DWORD PTR _cd$[esp+212]
	add	DWORD PTR [eax+48], 1

; 4881 :       PUT2(code, 1+LINK_SIZE, cd->bracount);

	mov	ecx, DWORD PTR [eax+48]
	sar	ecx, 8
	mov	BYTE PTR [ebp+3], cl
	mov	dl, BYTE PTR [eax+48]
	mov	BYTE PTR [ebp+4], dl

; 4882 :       skipbytes = 2;

	mov	DWORD PTR _skipbytes$6016[esp+216], 2
	mov	ebx, eax
	jmp	$LN822@compile_br
$LN116@compile_br:

; 4556 :         goto NUMBERED_GROUP;
; 4557 : 
; 4558 : 
; 4559 :         /* ------------------------------------------------------------ */
; 4560 :         case '&':                 /* Perl recursion/subroutine syntax */
; 4561 :         terminator = ')';

	mov	eax, 41					; 00000029H

; 4562 :         is_recurse = TRUE;

	mov	DWORD PTR _is_recurse$6009[esp+216], esi
	jmp	$NAMED_REF_OR_RECURSE$6547
$LN100@compile_br:

; 4632 :           else goto HANDLE_REFERENCE;
; 4633 : 
; 4634 : 
; 4635 :         /* ------------------------------------------------------------ */
; 4636 :         case 'R':                 /* Recursion */
; 4637 :         ptr++;                    /* Same as (?0)      */

	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi
$LN98@compile_br:

; 4638 :         /* Fall through */
; 4639 : 
; 4640 : 
; 4641 :         /* ------------------------------------------------------------ */
; 4642 :         case '-': case '+':
; 4643 :         case '0': case '1': case '2': case '3': case '4':   /* Recursion or */
; 4644 :         case '5': case '6': case '7': case '8': case '9':   /* subroutine */
; 4645 :           {
; 4646 :           const uschar *called;
; 4647 : 
; 4648 :           if ((refsign = *ptr) == '+')

	mov	al, BYTE PTR [edi]
	movzx	edx, al
	cmp	edx, 43					; 0000002bH
	jne	SHORT $LN97@compile_br

; 4649 :             {
; 4650 :             ptr++;

	add	edi, esi
	mov	DWORD PTR _ptr$[esp+216], edi

; 4651 :             if ((digitab[*ptr] & ctype_digit) == 0)

	movzx	eax, BYTE PTR [edi]
	mov	cl, 4
	test	BYTE PTR _digitab[eax], cl
	jne	SHORT $LN94@compile_br

; 4652 :               {
; 4653 :               *errorcodeptr = ERR63;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 63			; 0000003fH

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN97@compile_br:

; 4654 :               goto FAILED;
; 4655 :               }
; 4656 :             }
; 4657 :           else if (refsign == '-')

	cmp	edx, 45					; 0000002dH
	jne	SHORT $LN818@compile_br

; 4658 :             {
; 4659 :             if ((digitab[ptr[1]] & ctype_digit) == 0)

	movzx	ecx, BYTE PTR [edi+1]
	test	BYTE PTR _digitab[ecx], 4
	je	$OTHER_CHAR_AFTER_QUERY$6602
	add	edi, esi

; 4660 :               goto OTHER_CHAR_AFTER_QUERY;
; 4661 :             ptr++;

	mov	DWORD PTR _ptr$[esp+216], edi
$LN818@compile_br:
	mov	cl, 4
$LN94@compile_br:

; 4662 :             }
; 4663 : 
; 4664 :           recno = 0;
; 4665 :           while((digitab[*ptr] & ctype_digit) != 0)

	movzx	eax, BYTE PTR [edi]
	xor	ebx, ebx
	test	BYTE PTR _digitab[eax], cl
	mov	DWORD PTR _recno$6014[esp+216], ebx
	je	SHORT $LN91@compile_br
	npad	2
$LL819@compile_br:

; 4666 :             recno = recno * 10 + *ptr++ - '0';

	lea	esi, DWORD PTR [ebx+ebx*4]
	add	edi, 1
	lea	eax, DWORD PTR [eax+esi*2-48]
	mov	DWORD PTR _recno$6014[esp+216], eax
	mov	ebx, DWORD PTR _recno$6014[esp+216]
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	eax, BYTE PTR [edi]
	test	BYTE PTR _digitab[eax], cl
	jne	SHORT $LL819@compile_br
$LN91@compile_br:

; 4667 : 
; 4668 :           if (*ptr != ')')

	cmp	BYTE PTR [edi], 41			; 00000029H
	jne	$LN701@compile_br

; 4671 :             goto FAILED;
; 4672 :             }
; 4673 : 
; 4674 :           if (refsign == '-')

	cmp	edx, 45					; 0000002dH
	jne	SHORT $LN89@compile_br

; 4675 :             {
; 4676 :             if (recno == 0)

	test	ebx, ebx
	je	$LN691@compile_br

; 4677 :               {
; 4678 :               *errorcodeptr = ERR58;
; 4679 :               goto FAILED;
; 4680 :               }
; 4681 :             recno = cd->bracount - recno + 1;

	mov	ecx, DWORD PTR _cd$[esp+212]
	mov	eax, DWORD PTR [ecx+48]
	sub	eax, ebx
	add	eax, 1

; 4682 :             if (recno <= 0)

	test	eax, eax
	mov	DWORD PTR _recno$6014[esp+216], eax
	jg	$LN878@compile_br
$LN692@compile_br:

; 4295 :             {
; 4296 :             *errorcodeptr = ERR15;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 15			; 0000000fH

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN89@compile_br:

; 4683 :               {
; 4684 :               *errorcodeptr = ERR15;
; 4685 :               goto FAILED;
; 4686 :               }
; 4687 :             }
; 4688 :           else if (refsign == '+')

	cmp	edx, 43					; 0000002bH
	jne	$HANDLE_RECURSION$6591

; 4689 :             {
; 4690 :             if (recno == 0)

	test	ebx, ebx
	je	$LN704@compile_br

; 4693 :               goto FAILED;
; 4694 :               }
; 4695 :             recno += cd->bracount;

	mov	edx, DWORD PTR _cd$[esp+212]
	add	ebx, DWORD PTR [edx+48]
	mov	DWORD PTR _recno$6014[esp+216], ebx
	jmp	$HANDLE_RECURSION$6591
$OTHER_CHAR_AFTER_QUERY$6602:

; 4766 : 
; 4767 : 
; 4768 :         /* ------------------------------------------------------------ */
; 4769 :         default:              /* Other characters: check option setting */
; 4770 :         OTHER_CHAR_AFTER_QUERY:
; 4771 :         set = unset = 0;
; 4772 :         optset = &set;
; 4773 : 
; 4774 :         while (*ptr != ')' && *ptr != ':')

	mov	esi, DWORD PTR _cd$[esp+212]
	xor	ebx, ebx
	xor	edx, edx
	cmp	al, 41					; 00000029H
	mov	DWORD PTR _unset$6455[esp+216], ebx
	mov	DWORD PTR _set$6454[esp+216], edx
	lea	ecx, DWORD PTR _set$6454[esp+216]
	je	SHORT $LN74@compile_br
$LL75@compile_br:
	cmp	al, 58					; 0000003aH
	je	SHORT $LN780@compile_br

; 4775 :           {
; 4776 :           switch (*ptr++)

	movzx	eax, al
	add	edi, 1
	sub	eax, 45					; 0000002dH
	cmp	eax, 75					; 0000004bH
	mov	DWORD PTR _ptr$[esp+216], edi
	ja	$LN63@compile_br
	movzx	eax, BYTE PTR $LN770@compile_br[eax]
	jmp	DWORD PTR $LN890@compile_br[eax*4]
$LN71@compile_br:

; 4777 :             {
; 4778 :             case '-': optset = &unset; break;

	lea	ecx, DWORD PTR _unset$6455[esp+216]
	jmp	SHORT $LN72@compile_br
$LN70@compile_br:

; 4779 : 
; 4780 :             case 'J':    /* Record that it changed in the external options */
; 4781 :             *optset |= PCRE_DUPNAMES;

	or	DWORD PTR [ecx], 524288			; 00080000H

; 4782 :             cd->external_flags |= PCRE_JCHANGED;

	or	DWORD PTR [esi+68], 16			; 00000010H

; 4783 :             break;

	jmp	SHORT $LN72@compile_br
$LN69@compile_br:

; 4784 : 
; 4785 :             case 'i': *optset |= PCRE_CASELESS; break;

	or	DWORD PTR [ecx], 1
	jmp	SHORT $LN72@compile_br
$LN68@compile_br:

; 4786 :             case 'm': *optset |= PCRE_MULTILINE; break;

	or	DWORD PTR [ecx], 2
	jmp	SHORT $LN72@compile_br
$LN67@compile_br:

; 4787 :             case 's': *optset |= PCRE_DOTALL; break;

	or	DWORD PTR [ecx], 4
	jmp	SHORT $LN72@compile_br
$LN66@compile_br:

; 4788 :             case 'x': *optset |= PCRE_EXTENDED; break;

	or	DWORD PTR [ecx], 8
	jmp	SHORT $LN72@compile_br
$LN65@compile_br:

; 4789 :             case 'U': *optset |= PCRE_UNGREEDY; break;

	or	DWORD PTR [ecx], 512			; 00000200H
	jmp	SHORT $LN72@compile_br
$LN64@compile_br:

; 4790 :             case 'X': *optset |= PCRE_EXTRA; break;

	or	DWORD PTR [ecx], 64			; 00000040H
$LN72@compile_br:

; 4766 : 
; 4767 : 
; 4768 :         /* ------------------------------------------------------------ */
; 4769 :         default:              /* Other characters: check option setting */
; 4770 :         OTHER_CHAR_AFTER_QUERY:
; 4771 :         set = unset = 0;
; 4772 :         optset = &set;
; 4773 : 
; 4774 :         while (*ptr != ')' && *ptr != ':')

	mov	al, BYTE PTR [edi]
	cmp	al, 41					; 00000029H
	jne	SHORT $LL75@compile_br
$LN780@compile_br:
	mov	edx, DWORD PTR _set$6454[esp+216]
	mov	ebx, DWORD PTR _unset$6455[esp+216]
$LN74@compile_br:

; 4793 :                       ptr--;    /* Correct the offset */
; 4794 :                       goto FAILED;
; 4795 :             }
; 4796 :           }
; 4797 : 
; 4798 :         /* Set up the changed option bits, but don't change anything yet. */
; 4799 : 
; 4800 :         newoptions = (options | set) & (~unset);

	or	edx, DWORD PTR _options$[esp+216]
	not	ebx
	and	edx, ebx

; 4801 : 
; 4802 :         /* If the options ended with ')' this is not the start of a nested
; 4803 :         group with option changes, so the options change at this level. If this
; 4804 :         item is right at the start of the pattern, the options can be
; 4805 :         abstracted and made external in the pre-compile phase, and ignored in
; 4806 :         the compile phase. This can be helpful when matching -- for instance in
; 4807 :         caseless checking of required bytes.
; 4808 : 
; 4809 :         If the code pointer is not (cd->start_code + 1 + LINK_SIZE), we are
; 4810 :         definitely *not* at the start of the pattern because something has been
; 4811 :         compiled. In the pre-compile phase, however, the code pointer can have
; 4812 :         that value after the start, because it gets reset as code is discarded
; 4813 :         during the pre-compile. However, this can happen only at top level - if
; 4814 :         we are within parentheses, the starting BRA will still be present. At
; 4815 :         any parenthesis level, the length value can be used to test if anything
; 4816 :         has been compiled at that level. Thus, a test for both these conditions
; 4817 :         is necessary to ensure we correctly detect the start of the pattern in
; 4818 :         both phases.
; 4819 : 
; 4820 :         If we are not at the pattern start, compile code to change the ims
; 4821 :         options if this setting actually changes any of them. We also pass the
; 4822 :         new setting back so that it can be put at the start of any following
; 4823 :         branches, and when this group ends (if we are in a group), a resetting
; 4824 :         item can be compiled. */
; 4825 : 
; 4826 :         if (*ptr == ')')

	cmp	BYTE PTR [edi], 41			; 00000029H
	mov	eax, edx
	mov	DWORD PTR _newoptions$6013[esp+216], eax
	jne	$LN62@compile_br

; 4827 :           {
; 4828 :           if (code == cd->start_code + 1 + LINK_SIZE &&
; 4829 :                (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))

	mov	ecx, DWORD PTR [esi+20]
	add	ecx, 3
	cmp	ebp, ecx
	jne	SHORT $LN61@compile_br
	mov	ecx, DWORD PTR _lengthptr$[esp+212]
	test	ecx, ecx
	je	SHORT $LN60@compile_br
	cmp	DWORD PTR [ecx], 6
	jne	SHORT $LN61@compile_br
$LN60@compile_br:

; 2411 : 
; 2412 : /* Switch on next character until the end of the branch */
; 2413 : 
; 2414 : for (;; ptr++)

	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]

; 4830 :             {
; 4831 :             cd->external_options = newoptions;

	mov	DWORD PTR [esi+64], eax
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	add	edi, 1

; 4832 :             options = newoptions;

	mov	DWORD PTR _options$[esp+216], eax

; 4850 :             }
; 4851 : 
; 4852 :           previous = NULL;       /* This item can't be repeated */

	mov	DWORD PTR _previous$[esp+216], 0
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN61@compile_br:

; 4833 :             }
; 4834 :          else
; 4835 :             {
; 4836 :             if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))

	mov	edx, eax
	xor	edx, DWORD PTR _options$[esp+216]
	test	dl, 7
	je	SHORT $LN58@compile_br

; 4837 :               {
; 4838 :               *code++ = OP_OPT;

	mov	BYTE PTR [ebp], 24			; 00000018H

; 4839 :               *code++ = newoptions & PCRE_IMS;

	mov	cl, al
	add	ebp, 1
	and	cl, 7
	mov	BYTE PTR [ebp], cl
	mov	edi, DWORD PTR _ptr$[esp+216]
	add	ebp, 1
	mov	DWORD PTR _code$[esp+216], ebp
$LN58@compile_br:

; 4840 :               }
; 4841 : 
; 4842 :             /* Change options at this level, and pass them back for use
; 4843 :             in subsequent branches. Reset the greedy defaults and the case
; 4844 :             value for firstbyte and reqbyte. */
; 4845 : 
; 4846 :             *optionsptr = options = newoptions;

	mov	edx, DWORD PTR _optionsptr$[esp+212]
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]

; 4847 :             greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);

	mov	ecx, eax
	shr	ecx, 9
	and	ecx, 1
	mov	DWORD PTR [edx], eax
	mov	edx, DWORD PTR _last_code$[esp+216]
	mov	DWORD PTR _options$[esp+216], eax
	mov	DWORD PTR _greedy_default$[esp+216], ecx

; 4848 :             greedy_non_default = greedy_default ^ 1;
; 4849 :             req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;

	and	eax, 1
	xor	ecx, 1
	shl	eax, 8
	mov	DWORD PTR _greedy_non_default$[esp+216], ecx
	add	edi, 1
	mov	DWORD PTR _req_caseopt$[esp+216], eax

; 4850 :             }
; 4851 : 
; 4852 :           previous = NULL;       /* This item can't be repeated */

	mov	DWORD PTR _previous$[esp+216], 0
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN62@compile_br:

; 4853 :           continue;              /* It is complete */
; 4854 :           }
; 4855 : 
; 4856 :         /* If the options ended with ':' we are heading into a nested group
; 4857 :         with possible change of options. Such groups are non-capturing and are
; 4858 :         not assertions of any kind. All we need to do is skip over the ':';
; 4859 :         the newoptions value is handled below. */
; 4860 : 
; 4861 :         bravalue = OP_BRA;
; 4862 :         ptr++;

	add	edi, 1
	mov	DWORD PTR _bravalue$[esp+216], 93	; 0000005dH
	mov	DWORD PTR _ptr$[esp+216], edi

; 4863 :         }     /* End of switch for character following (? */
; 4864 :       }       /* End of (? handling */
; 4865 : 
; 4866 :     /* Opening parenthesis not followed by '?'. If PCRE_NO_AUTO_CAPTURE is set,
; 4867 :     all unadorned brackets become non-capturing and behave like (?:...)
; 4868 :     brackets. */
; 4869 : 
; 4870 :     else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)

	jmp	$LN821@compile_br
$LN207@compile_br:
	test	edx, 4096				; 00001000H
	je	$NUMBERED_GROUP$6570

; 4871 :       {
; 4872 :       bravalue = OP_BRA;

	mov	DWORD PTR _bravalue$[esp+216], 93	; 0000005dH

; 4873 :       }
; 4874 : 
; 4875 :     /* Else we have a capturing group. */
; 4876 : 
; 4877 :     else

	jmp	$LN821@compile_br
$LN49@compile_br:

; 4955 :         {
; 4956 :         if (condcount > 2)

	cmp	ecx, 2
	jg	$LN707@compile_br

; 4960 :           }
; 4961 :         if (condcount == 1) subfirstbyte = subreqbyte = REQ_NONE;

	cmp	ecx, 1
	jne	$LN781@compile_br
	or	edx, -1
	or	eax, edx
	mov	DWORD PTR _subreqbyte$6017[esp+216], edx
	mov	DWORD PTR _subfirstbyte$6018[esp+216], eax
	jmp	$LN45@compile_br
$LN43@compile_br:

; 4991 :       }
; 4992 : 
; 4993 :     /* Otherwise update the main code pointer to the end of the group. */
; 4994 : 
; 4995 :     code = tempcode;
; 4996 : 
; 4997 :     /* For a DEFINE group, required and first character settings are not
; 4998 :     relevant. */
; 4999 : 
; 5000 :     if (bravalue == OP_DEF) break;

	cmp	esi, 101				; 00000065H
	mov	ecx, DWORD PTR _tempcode$[esp+216]
	mov	DWORD PTR _code$[esp+216], ecx
	je	$LN785@compile_br

; 5001 : 
; 5002 :     /* Handle updating of the required and first characters for other types of
; 5003 :     group. Update for normal brackets of all kinds, and conditions with two
; 5004 :     branches (see code above). If the bracket is followed by a quantifier with
; 5005 :     zero repeat, we have to back off. Hence the definition of zeroreqbyte and
; 5006 :     zerofirstbyte outside the main loop so that they can be accessed for the
; 5007 :     back off. */
; 5008 : 
; 5009 :     zeroreqbyte = reqbyte;
; 5010 :     zerofirstbyte = firstbyte;
; 5011 :     groupsetfirstbyte = FALSE;
; 5012 : 
; 5013 :     if (bravalue >= OP_ONCE)

	cmp	esi, 92					; 0000005cH
	mov	ecx, DWORD PTR _reqbyte$[esp+216]
	mov	DWORD PTR _zeroreqbyte$[esp+216], ecx
	mov	ecx, DWORD PTR _firstbyte$[esp+216]
	mov	DWORD PTR _zerofirstbyte$[esp+216], ecx
	mov	DWORD PTR _groupsetfirstbyte$[esp+216], 0
	jl	SHORT $LN40@compile_br

; 5014 :       {
; 5015 :       /* If we have not yet set a firstbyte in this branch, take it from the
; 5016 :       subpattern, remembering that it was set here so that a repeat of more
; 5017 :       than one can replicate it as reqbyte if necessary. If the subpattern has
; 5018 :       no firstbyte, set "none" for the whole branch. In both cases, a zero
; 5019 :       repeat forces firstbyte to "none". */
; 5020 : 
; 5021 :       if (firstbyte == REQ_UNSET)

	cmp	ecx, -2					; fffffffeH
	jne	SHORT $LN39@compile_br

; 5022 :         {
; 5023 :         if (subfirstbyte >= 0)

	test	eax, eax
	jl	SHORT $LN38@compile_br

; 5024 :           {
; 5025 :           firstbyte = subfirstbyte;

	mov	DWORD PTR _firstbyte$[esp+216], eax

; 5026 :           groupsetfirstbyte = TRUE;

	mov	DWORD PTR _groupsetfirstbyte$[esp+216], 1

; 5029 :         zerofirstbyte = REQ_NONE;

	mov	DWORD PTR _zerofirstbyte$[esp+216], -1
	jmp	SHORT $LN35@compile_br
$LN38@compile_br:

; 5027 :           }
; 5028 :         else firstbyte = REQ_NONE;

	mov	DWORD PTR _firstbyte$[esp+216], -1

; 5029 :         zerofirstbyte = REQ_NONE;

	mov	DWORD PTR _zerofirstbyte$[esp+216], -1
	jmp	SHORT $LN35@compile_br
$LN39@compile_br:

; 5030 :         }
; 5031 : 
; 5032 :       /* If firstbyte was previously set, convert the subpattern's firstbyte
; 5033 :       into reqbyte if there wasn't one, using the vary flag that was in
; 5034 :       existence beforehand. */
; 5035 : 
; 5036 :       else if (subfirstbyte >= 0 && subreqbyte < 0)

	test	eax, eax
	jl	SHORT $LN35@compile_br
	test	edx, edx
	jge	SHORT $LN753@compile_br

; 5037 :         subreqbyte = subfirstbyte | tempreqvary;

	or	eax, DWORD PTR _tempreqvary$[esp+216]
	mov	edx, eax
	mov	DWORD PTR _subreqbyte$6017[esp+216], edx
$LN35@compile_br:

; 5038 : 
; 5039 :       /* If the subpattern set a required byte (or set a first byte that isn't
; 5040 :       really the first byte - see above), set it. */
; 5041 : 
; 5042 :       if (subreqbyte >= 0) reqbyte = subreqbyte;

	test	edx, edx
	jl	SHORT $LN785@compile_br
$LN753@compile_br:

; 5043 :       }
; 5044 : 
; 5045 :     /* For a forward assertion, we take the reqbyte, if set. This can be
; 5046 :     helpful if the pattern that follows the assertion doesn't set a different
; 5047 :     char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
; 5048 :     for an assertion, however because it leads to incorrect effect for patterns
; 5049 :     such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
; 5050 :     of a firstbyte. This is overcome by a scan at the end if there's no
; 5051 :     firstbyte, looking for an asserted first char. */
; 5052 : 
; 5053 :     else if (bravalue == OP_ASSERT && subreqbyte >= 0) reqbyte = subreqbyte;

	mov	ebp, DWORD PTR _code$[esp+216]
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	DWORD PTR _reqbyte$[esp+216], edx
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN40@compile_br:
	cmp	esi, 87					; 00000057H
	jne	SHORT $LN785@compile_br
	test	edx, edx
	jl	SHORT $LN785@compile_br
	mov	DWORD PTR _reqbyte$[esp+216], edx
$LN785@compile_br:

; 5054 :     break;     /* End of processing '(' */

	mov	ebp, DWORD PTR _code$[esp+216]
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN31@compile_br:

; 5055 : 
; 5056 : 
; 5057 :     /* ===================================================================*/
; 5058 :     /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
; 5059 :     are arranged to be the negation of the corresponding OP_values. For the
; 5060 :     back references, the values are ESC_REF plus the reference number. Only
; 5061 :     back references and those types that consume a character may be repeated.
; 5062 :     We can test for values between ESC_b and ESC_Z for the latter; this may
; 5063 :     have to change if any new ones are ever created. */
; 5064 : 
; 5065 :     case '\\':
; 5066 :     tempptr = ptr;
; 5067 :     c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);

	mov	edx, DWORD PTR [ebx+48]
	mov	esi, DWORD PTR _errorcodeptr$[esp+212]
	push	0
	push	edx
	lea	eax, DWORD PTR _ptr$[esp+224]
	push	esi
	push	eax
	mov	eax, DWORD PTR _options$[esp+232]
	mov	DWORD PTR _tempptr$[esp+232], edi
	call	_check_escape
	add	esp, 16					; 00000010H

; 5068 :     if (*errorcodeptr != 0) goto FAILED;

	cmp	DWORD PTR [esi], 0
	jne	$LN789@compile_br

; 5069 : 
; 5070 :     if (c < 0)

	test	eax, eax
	jge	$ONE_CHAR$6253

; 5071 :       {
; 5072 :       if (-c == ESC_Q)            /* Handle start of quoted string */

	mov	ecx, eax
	neg	ecx
	cmp	ecx, 25					; 00000019H
	jne	SHORT $LN28@compile_br

; 5073 :         {
; 5074 :         if (ptr[1] == '\\' && ptr[2] == 'E') ptr += 2; /* avoid empty string */

	mov	edi, DWORD PTR _ptr$[esp+216]
	cmp	BYTE PTR [edi+1], 92			; 0000005cH
	jne	SHORT $LN27@compile_br
	cmp	BYTE PTR [edi+2], 69			; 00000045H
	jne	SHORT $LN27@compile_br
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 2
	add	edi, 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN27@compile_br:

; 2411 : 
; 2412 : /* Switch on next character until the end of the branch */
; 2413 : 
; 2414 : for (;; ptr++)

	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1

; 5075 :           else inescq = TRUE;

	mov	DWORD PTR _inescq$[esp+216], 1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN28@compile_br:

; 5076 :         continue;
; 5077 :         }
; 5078 : 
; 5079 :       if (-c == ESC_E) continue;  /* Perl ignores an orphan \E */

	cmp	ecx, 24					; 00000018H
	je	$LN787@compile_br

; 5080 : 
; 5081 :       /* For metasequences that actually match a character, we disable the
; 5082 :       setting of a first character if it hasn't already been set. */
; 5083 : 
; 5084 :       if (firstbyte == REQ_UNSET && -c > ESC_b && -c < ESC_Z)

	mov	edx, DWORD PTR _firstbyte$[esp+216]
	cmp	edx, -2					; fffffffeH
	jne	SHORT $LN854@compile_br
	cmp	ecx, 5
	jle	SHORT $LN854@compile_br
	cmp	ecx, 22					; 00000016H
	jge	SHORT $LN854@compile_br

; 5085 :         firstbyte = REQ_NONE;

	or	edx, -1
	mov	DWORD PTR _firstbyte$[esp+216], edx
$LN854@compile_br:

; 5086 : 
; 5087 :       /* Set values to reset to if this is followed by a zero repeat. */
; 5088 : 
; 5089 :       zerofirstbyte = firstbyte;
; 5090 :       zeroreqbyte = reqbyte;
; 5091 : 
; 5092 :       /* \k<name> or \k'name' is a back reference by name (Perl syntax).
; 5093 :       We also support \k{name} (.NET syntax) */
; 5094 : 
; 5095 :       if (-c == ESC_k && (ptr[1] == '<' || ptr[1] == '\'' || ptr[1] == '{'))

	cmp	ecx, 26					; 0000001aH
	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	DWORD PTR _zerofirstbyte$[esp+216], edx
	mov	edx, DWORD PTR _reqbyte$[esp+216]
	mov	DWORD PTR _zeroreqbyte$[esp+216], edx
	jne	$LN23@compile_br
	mov	dl, BYTE PTR [edi+1]
	cmp	dl, 60					; 0000003cH
	je	SHORT $LN824@compile_br
	cmp	dl, 39					; 00000027H
	je	SHORT $LN824@compile_br
	cmp	dl, 123					; 0000007bH
	jne	$LN23@compile_br
$LN824@compile_br:
	add	edi, 1

; 5096 :         {
; 5097 :         is_recurse = FALSE;
; 5098 :         terminator = (*(++ptr) == '<')? '>' : (*ptr == '\'')? '\'' : '}';

	mov	DWORD PTR _ptr$[esp+216], edi
	mov	al, BYTE PTR [edi]
	cmp	al, 60					; 0000003cH
	mov	DWORD PTR _is_recurse$6009[esp+216], 0
	jne	SHORT $LN566@compile_br
	mov	eax, 62					; 0000003eH
	jmp	SHORT $NAMED_REF_OR_RECURSE$6547
$LN566@compile_br:
	sub	al, 39					; 00000027H
	neg	al
	sbb	eax, eax
	and	eax, 86					; 00000056H
	add	eax, 39					; 00000027H
$NAMED_REF_OR_RECURSE$6547:
	mov	edx, DWORD PTR [ebx+12]
	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	ecx, BYTE PTR [edi]
	test	BYTE PTR [ecx+edx], 16			; 00000010H
	mov	DWORD PTR _name$6458[esp+216], edi
	je	SHORT $LN114@compile_br
	mov	ecx, edx
	npad	1
$LL115@compile_br:

; 4563 :         /* Fall through */
; 4564 : 
; 4565 :         /* We come here from the Python syntax above that handles both
; 4566 :         references (?P=name) and recursion (?P>name), as well as falling
; 4567 :         through from the Perl recursion syntax (?&name). We also come here from
; 4568 :         the Perl \k<name> or \k'name' back reference syntax and the \k{name}
; 4569 :         .NET syntax. */
; 4570 : 
; 4571 :         NAMED_REF_OR_RECURSE:
; 4572 :         name = ++ptr;
; 4573 :         while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+216], edi
	movzx	edx, BYTE PTR [edi]
	test	BYTE PTR [edx+ecx], 16			; 00000010H
	jne	SHORT $LL115@compile_br
$LN114@compile_br:

; 4574 :         namelen = ptr - name;

	mov	esi, edi
	sub	esi, DWORD PTR _name$6458[esp+216]

; 4575 : 
; 4576 :         /* In the pre-compile phase, do a syntax check and set a dummy
; 4577 :         reference number. */
; 4578 : 
; 4579 :         if (lengthptr != NULL)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	je	SHORT $LN113@compile_br

; 4580 :           {
; 4581 :           if (namelen == 0)

	test	esi, esi
	je	$LN711@compile_br

; 4584 :             goto FAILED;
; 4585 :             }
; 4586 :           if (*ptr != terminator)

	movzx	ecx, BYTE PTR [edi]
	cmp	ecx, eax
	jne	$LN712@compile_br

; 4589 :             goto FAILED;
; 4590 :             }
; 4591 :           if (namelen > MAX_NAME_SIZE)

	cmp	esi, 32					; 00000020H
	jg	$LN713@compile_br

; 4594 :             goto FAILED;
; 4595 :             }
; 4596 :           recno = 0;
; 4597 :           }
; 4598 : 
; 4599 :         /* In the real compile, seek the name in the table. We check the name
; 4600 :         first, and then check that we have reached the end of the name in the
; 4601 :         table. That way, if the name that is longer than any in the table,
; 4602 :         the comparison will fail without reading beyond the table entry. */
; 4603 : 
; 4604 :         else

	mov	esi, DWORD PTR _cd$[esp+212]
	mov	DWORD PTR _recno$6014[esp+216], 0
	jmp	$LN102@compile_br
$LN113@compile_br:

; 4605 :           {
; 4606 :           slot = cd->name_table;

	mov	eax, DWORD PTR _cd$[esp+212]

; 4607 :           for (i = 0; i < cd->names_found; i++)

	cmp	DWORD PTR [eax+40], 0
	mov	ebx, DWORD PTR [eax+36]
	mov	DWORD PTR _i$6453[esp+216], 0
	jle	SHORT $LN676@compile_br
	mov	edi, DWORD PTR _i$6453[esp+216]
	npad	4
$LL108@compile_br:

; 4608 :             {
; 4609 :             if (strncmp((char *)name, (char *)slot+2, namelen) == 0 &&
; 4610 :                 slot[2+namelen] == 0)

	mov	eax, DWORD PTR _name$6458[esp+216]
	push	esi
	lea	edx, DWORD PTR [ebx+2]
	push	edx
	push	eax
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN105@compile_br
	cmp	BYTE PTR [ebx+esi+2], al
	je	SHORT $LN782@compile_br
$LN105@compile_br:

; 4611 :               break;
; 4612 :             slot += cd->name_entry_size;

	mov	eax, DWORD PTR _cd$[esp+212]
	add	ebx, DWORD PTR [eax+44]
	add	edi, 1
	cmp	edi, DWORD PTR [eax+40]
	mov	DWORD PTR _i$6453[esp+216], edi
	jl	SHORT $LL108@compile_br
$LN782@compile_br:

; 4607 :           for (i = 0; i < cd->names_found; i++)

	mov	edi, DWORD PTR _ptr$[esp+216]
$LN676@compile_br:

; 4613 :             }
; 4614 : 
; 4615 :           if (i < cd->names_found)         /* Back reference */

	mov	ecx, DWORD PTR _i$6453[esp+216]
	mov	edx, DWORD PTR _cd$[esp+212]
	cmp	ecx, DWORD PTR [edx+40]
	jge	SHORT $LN104@compile_br

; 4616 :             {
; 4617 :             recno = GET2(slot, 0);

	movzx	eax, BYTE PTR [ebx+1]
	mov	ah, BYTE PTR [ebx]

; 4618 :             }
; 4619 :           else if ((recno =                /* Forward back reference */

	mov	esi, edx
	mov	DWORD PTR _recno$6014[esp+216], eax
	jmp	SHORT $LN102@compile_br
$LN104@compile_br:

; 4620 :                     find_parens(ptr, cd->bracount, name, namelen,
; 4621 :                       (options & PCRE_EXTENDED) != 0)) <= 0)

	mov	ecx, DWORD PTR _options$[esp+216]
	mov	ebx, DWORD PTR _name$6458[esp+216]
	shr	ecx, 3
	and	ecx, 1
	push	ecx
	push	esi
	mov	esi, edx
	mov	eax, DWORD PTR [esi+48]
	mov	ecx, edi
	call	_find_parens
	add	esp, 8
	test	eax, eax
	mov	DWORD PTR _recno$6014[esp+216], eax
	jle	$LN714@compile_br
	mov	ebp, DWORD PTR _code$[esp+216]
$LN102@compile_br:

; 4625 :             }
; 4626 :           }
; 4627 : 
; 4628 :         /* In both phases, we can now go to the code than handles numerical
; 4629 :         recursion or backreferences. */
; 4630 : 
; 4631 :         if (is_recurse) goto HANDLE_RECURSION;

	cmp	DWORD PTR _is_recurse$6009[esp+216], 0
	je	$LN825@compile_br
$LN878@compile_br:
	mov	ebx, DWORD PTR _recno$6014[esp+216]
$HANDLE_RECURSION$6591:

; 4696 :             }
; 4697 : 
; 4698 :           /* Come here from code above that handles a named recursion */
; 4699 : 
; 4700 :           HANDLE_RECURSION:
; 4701 : 
; 4702 :           previous = code;
; 4703 :           called = cd->start_code;
; 4704 : 
; 4705 :           /* When we are actually compiling, find the bracket that is being
; 4706 :           referenced. Temporarily end the regex in case it doesn't exist before
; 4707 :           this point. If we end up with a forward reference, first check that
; 4708 :           the bracket does occur later so we can give the error (and position)
; 4709 :           now. Then remember this forward reference in the workspace so it can
; 4710 :           be filled in at the end. */
; 4711 : 
; 4712 :           if (lengthptr == NULL)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	mov	esi, DWORD PTR _cd$[esp+212]
	mov	eax, DWORD PTR [esi+20]
	mov	DWORD PTR _previous$[esp+216], ebp
	mov	DWORD PTR _called$6596[esp+216], eax
	jne	$LN78@compile_br

; 4713 :             {
; 4714 :             *code = OP_END;
; 4715 :             if (recno != 0) called = find_bracket(cd->start_code, utf8, recno);

	test	ebx, ebx
	mov	BYTE PTR [ebp], 0
	je	SHORT $LN82@compile_br
	mov	edx, DWORD PTR _cd$[esp+212]
	mov	eax, DWORD PTR [edx+20]
	mov	esi, ebx
	call	_find_bracket
	mov	esi, DWORD PTR _cd$[esp+212]
	mov	DWORD PTR _called$6596[esp+216], eax
$LN82@compile_br:

; 4716 : 
; 4717 :             /* Forward reference */
; 4718 : 
; 4719 :             if (called == NULL)

	test	eax, eax
	jne	SHORT $LN81@compile_br

; 4720 :               {
; 4721 :               if (find_parens(ptr, cd->bracount, NULL, recno,
; 4722 :                    (options & PCRE_EXTENDED) != 0) < 0)

	mov	eax, DWORD PTR _options$[esp+216]
	mov	ecx, DWORD PTR _ptr$[esp+216]
	shr	eax, 3
	and	eax, 1
	push	eax
	mov	eax, DWORD PTR [esi+48]
	push	ebx
	xor	ebx, ebx
	call	_find_parens
	add	esp, 8
	test	eax, eax
	jl	$LN693@compile_br

; 4723 :                 {
; 4724 :                 *errorcodeptr = ERR15;
; 4725 :                 goto FAILED;
; 4726 :                 }
; 4727 :               called = cd->start_code + recno;

	mov	eax, DWORD PTR [esi+20]
	mov	ecx, DWORD PTR _recno$6014[esp+216]
	lea	edx, DWORD PTR [eax+ecx]

; 4728 :               PUTINC(cd->hwm, 0, code + 2 + LINK_SIZE - cd->start_code);

	mov	ecx, DWORD PTR _code$[esp+216]
	mov	DWORD PTR _called$6596[esp+216], edx
	mov	edx, ecx
	sub	edx, eax
	mov	eax, DWORD PTR [esi+32]
	add	edx, 4
	sar	edx, 8
	mov	BYTE PTR [eax], dl
	sub	cl, BYTE PTR [esi+20]
	mov	edx, DWORD PTR [esi+32]
	add	cl, 4
	mov	BYTE PTR [edx+1], cl
	add	DWORD PTR [esi+32], 2

; 4729 :               }
; 4730 : 
; 4731 :             /* If not a forward reference, and the subpattern is still open,
; 4732 :             this is a recursive call. We check to see if this is a left
; 4733 :             recursion that could loop for ever, and diagnose that case. */
; 4734 : 
; 4735 :             else if (GET(called, 1) == 0 &&

	jmp	SHORT $LN881@compile_br
$LN81@compile_br:

; 4736 :                      could_be_empty(called, code, bcptr, utf8))

	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+1]
	mov	cl, BYTE PTR [eax+2]
	test	ecx, ecx
	jne	SHORT $LN78@compile_br
	push	eax
	mov	eax, DWORD PTR _bcptr$[esp+216]
	xor	edi, edi
	mov	ebx, ebp
	call	_could_be_empty
	add	esp, 4
	test	eax, eax
	jne	$LN716@compile_br
$LN881@compile_br:
	mov	ebp, DWORD PTR _code$[esp+216]
	mov	eax, DWORD PTR _called$6596[esp+216]
$LN78@compile_br:

; 4740 :               }
; 4741 :             }
; 4742 : 
; 4743 :           /* Insert the recursion/subroutine item, automatically wrapped inside
; 4744 :           "once" brackets. Set up a "previous group" length so that a
; 4745 :           subsequent quantifier will work. */
; 4746 : 
; 4747 :           *code = OP_ONCE;

	mov	BYTE PTR [ebp], 92			; 0000005cH

; 4748 :           PUT(code, 1, 2 + 2*LINK_SIZE);

	mov	BYTE PTR [ebp+1], 0

; 4749 :           code += 1 + LINK_SIZE;

	add	ebp, 3
	mov	cl, 6
	mov	BYTE PTR [ebp-1], cl

; 4750 : 
; 4751 :           *code = OP_RECURSE;

	mov	BYTE PTR [ebp], 81			; 00000051H

; 4752 :           PUT(code, 1, called - cd->start_code);

	mov	edx, eax
	sub	edx, DWORD PTR [esi+20]

; 4753 :           code += 1 + LINK_SIZE;

	add	ebp, 3
	sar	edx, 8
	mov	BYTE PTR [ebp-2], dl
	sub	al, BYTE PTR [esi+20]

; 4754 : 
; 4755 :           *code = OP_KET;
; 4756 :           PUT(code, 1, 2 + 2*LINK_SIZE);
; 4757 :           code += 1 + LINK_SIZE;

	add	ebp, 3

; 4758 : 
; 4759 :           length_prevgroup = 3 + 3*LINK_SIZE;
; 4760 :           }
; 4761 : 
; 4762 :         /* Can't determine a first byte now */
; 4763 : 
; 4764 :         if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;

	cmp	DWORD PTR _firstbyte$[esp+216], -2	; fffffffeH
	mov	BYTE PTR [ebp-4], al
	mov	BYTE PTR [ebp-3], 84			; 00000054H
	mov	BYTE PTR [ebp-2], 0
	mov	BYTE PTR [ebp-1], cl

; 4765 :         continue;

	mov	edi, DWORD PTR _ptr$[esp+216]
	mov	DWORD PTR _code$[esp+216], ebp
	mov	DWORD PTR _length_prevgroup$[esp+216], 9
	jne	$LN537@compile_br
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	mov	DWORD PTR _firstbyte$[esp+216], -1
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN23@compile_br:

; 5099 :         goto NAMED_REF_OR_RECURSE;
; 5100 :         }
; 5101 : 
; 5102 :       /* Back references are handled specially; must disable firstbyte if
; 5103 :       not set to cope with cases like (?=(\w+))\1: which would otherwise set
; 5104 :       ':' later. */
; 5105 : 
; 5106 :       if (-c >= ESC_REF)

	cmp	ecx, 27					; 0000001bH
	jl	SHORT $LN21@compile_br

; 5107 :         {
; 5108 :         recno = -c - ESC_REF;

	mov	esi, DWORD PTR _cd$[esp+212]
	mov	ecx, -27				; ffffffe5H
	sub	ecx, eax
	jmp	SHORT $HANDLE_REFERENCE$6593
$LN825@compile_br:
	mov	ecx, DWORD PTR _recno$6014[esp+216]
$HANDLE_REFERENCE$6593:

; 5109 : 
; 5110 :         HANDLE_REFERENCE:    /* Come here from named backref handling */
; 5111 :         if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;

	cmp	DWORD PTR _firstbyte$[esp+216], -2	; fffffffeH
	jne	SHORT $LN20@compile_br
	mov	DWORD PTR _firstbyte$[esp+216], -1
$LN20@compile_br:

; 5112 :         previous = code;
; 5113 :         *code++ = OP_REF;

	mov	BYTE PTR [ebp], 80			; 00000050H
	mov	DWORD PTR _previous$[esp+216], ebp
	add	ebp, 1

; 5114 :         PUT2INC(code, 0, recno);

	mov	eax, ecx
	sar	eax, 8
	mov	BYTE PTR [ebp], al
	mov	BYTE PTR [ebp+1], cl
	add	ebp, 2

; 5115 :         cd->backref_map |= (recno < 32)? (1 << recno) : 1;

	cmp	ecx, 32					; 00000020H
	mov	DWORD PTR _code$[esp+216], ebp
	mov	eax, 1
	jge	SHORT $LN569@compile_br
	shl	eax, cl
$LN569@compile_br:
	or	DWORD PTR [esi+60], eax

; 5116 :         if (recno > cd->top_backref) cd->top_backref = recno;

	cmp	ecx, DWORD PTR [esi+56]
	jle	$LN787@compile_br
	mov	DWORD PTR [esi+56], ecx

; 5117 :         }
; 5118 : 
; 5119 :       /* So are Unicode property matches, if supported. */
; 5120 : 
; 5121 : #ifdef SUPPORT_UCP
; 5122 :       else if (-c == ESC_P || -c == ESC_p)
; 5123 :         {
; 5124 :         BOOL negated;
; 5125 :         int pdata;
; 5126 :         int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
; 5127 :         if (ptype < 0) goto FAILED;
; 5128 :         previous = code;
; 5129 :         *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
; 5130 :         *code++ = ptype;
; 5131 :         *code++ = pdata;
; 5132 :         }
; 5133 : #else
; 5134 : 
; 5135 :       /* If Unicode properties are not supported, \X, \P, and \p are not
; 5136 :       allowed. */
; 5137 : 
; 5138 :       else if (-c == ESC_X || -c == ESC_P || -c == ESC_p)

	jmp	$LN787@compile_br
$LN21@compile_br:
	cmp	ecx, 21					; 00000015H
	je	$LN717@compile_br
	cmp	ecx, 14					; 0000000eH
	je	$LN717@compile_br
	cmp	ecx, 15					; 0000000fH
	je	$LN717@compile_br

; 5139 :         {
; 5140 :         *errorcodeptr = ERR45;
; 5141 :         goto FAILED;
; 5142 :         }
; 5143 : #endif
; 5144 : 
; 5145 :       /* For the rest (including \X when Unicode properties are supported), we
; 5146 :       can obtain the OP value by negating the escape value. */
; 5147 : 
; 5148 :       else
; 5149 :         {
; 5150 :         previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;

	cmp	ecx, 5
	jle	SHORT $LN570@compile_br
	cmp	ecx, 22					; 00000016H
	mov	DWORD PTR _previous$[esp+216], ebp
	jl	SHORT $LN571@compile_br
$LN570@compile_br:
	mov	DWORD PTR _previous$[esp+216], 0
$LN571@compile_br:

; 5151 :         *code++ = -c;

	neg	al
	mov	BYTE PTR [ebp], al

; 5152 :         }
; 5153 :       continue;

	jmp	$LN882@compile_br
$LN843@compile_br:

; 5202 :       cd->external_flags |= PCRE_HASCRORLF;

	mov	ecx, DWORD PTR _cd$[esp+212]
$LN10@compile_br:

; 5203 : 
; 5204 :     /* Set the first and required bytes appropriately. If no previous first
; 5205 :     byte, set it from this character, but revert to none on a zero repeat.
; 5206 :     Otherwise, leave the firstbyte value alone, and don't change it on a zero
; 5207 :     repeat. */
; 5208 : 
; 5209 :     if (firstbyte == REQ_UNSET)

	mov	edx, DWORD PTR _firstbyte$[esp+216]
	cmp	edx, -2					; fffffffeH

; 5210 :       {
; 5211 :       zerofirstbyte = REQ_NONE;
; 5212 :       zeroreqbyte = reqbyte;
; 5213 : 
; 5214 :       /* If the character is more than one byte long, we can set firstbyte
; 5215 :       only if it is not to be matched caselessly. */
; 5216 : 
; 5217 :       if (mclength == 1 || req_caseopt == 0)
; 5218 :         {
; 5219 :         firstbyte = mcbuffer[0] | req_caseopt;
; 5220 :         if (mclength != 1) reqbyte = code[-1] | cd->req_varyopt;
; 5221 :         }
; 5222 :       else firstbyte = reqbyte = REQ_NONE;
; 5223 :       }
; 5224 : 
; 5225 :     /* firstbyte was previously set; we can set reqbyte only the length is
; 5226 :     1 or the matching is caseful. */
; 5227 : 
; 5228 :     else

	mov	edi, DWORD PTR _ptr$[esp+216]
	jne	SHORT $LN8@compile_br
	mov	edx, DWORD PTR _reqbyte$[esp+216]
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	movzx	eax, al
	or	eax, DWORD PTR _req_caseopt$[esp+216]
	mov	DWORD PTR _zeroreqbyte$[esp+216], edx
	mov	edx, DWORD PTR _last_code$[esp+216]
	add	edi, 1
	mov	DWORD PTR _zerofirstbyte$[esp+216], -1
	mov	DWORD PTR _firstbyte$[esp+216], eax
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN8@compile_br:

; 5229 :       {
; 5230 :       zerofirstbyte = firstbyte;
; 5231 :       zeroreqbyte = reqbyte;

	mov	eax, DWORD PTR _reqbyte$[esp+216]
	mov	esi, DWORD PTR _previous_callout$[esp+216]
	mov	ebx, DWORD PTR _orig_code$[esp+216]
	mov	DWORD PTR _zerofirstbyte$[esp+216], edx

; 5232 :       if (mclength == 1 || req_caseopt == 0)
; 5233 :         reqbyte = code[-1] | req_caseopt | cd->req_varyopt;

	movzx	edx, BYTE PTR [ebp-1]
	or	edx, DWORD PTR [ecx+72]
	add	edi, 1
	or	edx, DWORD PTR _req_caseopt$[esp+216]
	mov	DWORD PTR _zeroreqbyte$[esp+216], eax
	mov	DWORD PTR _reqbyte$[esp+216], edx
	mov	edx, DWORD PTR _last_code$[esp+216]
	xor	ecx, ecx
	jmp	$LN883@compile_br
$LN677@compile_br:

; 2447 :       {
; 2448 :       *errorcodeptr = ERR52;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 52			; 00000034H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN678@compile_br:

; 2463 :       {
; 2464 :       *errorcodeptr = ERR20;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 20			; 00000014H

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN679@compile_br:

; 2496 :     {
; 2497 :     *errorcodeptr = ERR52;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 52			; 00000034H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN508@compile_br:

; 2569 :     {
; 2570 :     /* ===================================================================*/
; 2571 :     case 0:                        /* The branch terminates at string end */
; 2572 :     case '|':                      /* or | or ) */
; 2573 :     case ')':
; 2574 :     *firstbyteptr = firstbyte;
; 2575 :     *reqbyteptr = reqbyte;
; 2576 :     *codeptr = code;
; 2577 :     *ptrptr = ptr;
; 2578 :     if (lengthptr != NULL)

	cmp	DWORD PTR _lengthptr$[esp+212], 0
	mov	eax, DWORD PTR _firstbyteptr$[esp+212]
	mov	ecx, DWORD PTR _firstbyte$[esp+216]
	mov	edx, DWORD PTR _reqbyteptr$[esp+212]
	mov	DWORD PTR [eax], ecx
	mov	eax, DWORD PTR _reqbyte$[esp+216]
	mov	ecx, DWORD PTR _codeptr$[esp+212]
	mov	DWORD PTR [edx], eax
	mov	edx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], ebp
	mov	DWORD PTR [edx], edi
	je	SHORT $LN507@compile_br

; 2579 :       {
; 2580 :       if (OFLOW_MAX - *lengthptr < code - last_code)

	mov	edx, DWORD PTR _lengthptr$[esp+212]
	mov	eax, DWORD PTR [edx]
	mov	ecx, DWORD PTR _last_code$[esp+216]
	mov	esi, ebp
	mov	ebx, 2147483627				; 7fffffebH
	sub	esi, ecx
	sub	ebx, eax
	cmp	ebx, esi
	jge	SHORT $LN506@compile_br

; 2581 :         {
; 2582 :         *errorcodeptr = ERR20;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 20			; 00000014H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN506@compile_br:

; 2583 :         goto FAILED;
; 2584 :         }
; 2585 :       *lengthptr += code - last_code;   /* To include callout length */

	sub	eax, ecx
	add	eax, ebp
	mov	DWORD PTR [edx], eax
$LN507@compile_br:
	pop	edi
	pop	esi
	pop	ebp

; 2586 :       DPRINTF((">> end branch\n"));
; 2587 :       }
; 2588 :     return TRUE;

	mov	eax, 1
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN680@compile_br:

; 2642 :       {
; 2643 :       *errorcodeptr = (ptr[1] == ':')? ERR13 : ERR31;

	mov	cl, BYTE PTR [edi+1]
	mov	edx, DWORD PTR _errorcodeptr$[esp+212]
	sub	cl, 58					; 0000003aH
	neg	cl
	sbb	ecx, ecx
	and	ecx, 18					; 00000012H
	add	ecx, 13					; 0000000dH
	mov	DWORD PTR [edx], ecx

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN663@compile_br:

; 2748 :           {
; 2749 :           *errorcodeptr = ERR31;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 31			; 0000001fH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN664@compile_br:

; 2763 :           {
; 2764 :           *errorcodeptr = ERR30;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 30			; 0000001eH

; 2765 :           goto FAILED;

	jmp	$LN789@compile_br
$LN666@compile_br:

; 3043 :             {
; 3044 :             *errorcodeptr = ERR7;

	mov	DWORD PTR [edi], 7

; 3045 :             goto FAILED;

	jmp	$LN789@compile_br
$LN668@compile_br:

; 3137 :           {
; 3138 :           *errorcodeptr = ERR8;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 8
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN681@compile_br:

; 3294 : 
; 3295 :     if (c == 0)                          /* Missing terminating ']' */
; 3296 :       {
; 3297 :       *errorcodeptr = ERR6;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 6
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN683@compile_br:

; 3460 :       {
; 3461 :       *errorcodeptr = ERR9;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 9

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN285@compile_br:

; 4040 :       {
; 4041 :       *errorcodeptr = ERR11;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 11			; 0000000bH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN684@compile_br:

; 3794 :         {
; 3795 :         *errorcodeptr = ERR55;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 55			; 00000037H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN686@compile_br:

; 3950 :             {
; 3951 :             *errorcodeptr = ERR20;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 20			; 00000014H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN687@compile_br:

; 4128 :         {
; 4129 :         *errorcodeptr = ERR59;   /* Not supported */

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 59			; 0000003bH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN688@compile_br:

; 4133 :         {
; 4134 :         *errorcodeptr = ERR60;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 60			; 0000003cH

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN690@compile_br:

; 4251 :           {
; 4252 :           ptr += 1;  /* To get the right offset */
; 4253 :           *errorcodeptr = ERR28;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 28			; 0000001cH

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN182@compile_br:

; 4271 :           {
; 4272 :           ptr--;      /* Error offset */
; 4273 :           *errorcodeptr = ERR26;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	sub	edi, 1
	mov	DWORD PTR [edx], 26			; 0000001aH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN691@compile_br:

; 4288 :             {
; 4289 :             *errorcodeptr = ERR58;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 58			; 0000003aH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN693@compile_br:

; 4336 :           {
; 4337 :           *errorcodeptr = ERR15;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [edx], 15			; 0000000fH
	jmp	$LN789@compile_br
$LN672@compile_br:

; 4350 :               {
; 4351 :               *errorcodeptr = ERR15;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [eax], 15			; 0000000fH

; 4352 :               goto FAILED;

	jmp	$LN789@compile_br
$LN145@compile_br:

; 4424 :           ptr++;                  /* Correct offset for error */
; 4425 :           *errorcodeptr = ERR24;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	add	edi, esi
	mov	DWORD PTR [edx], 24			; 00000018H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN694@compile_br:

; 4448 :             {
; 4449 :             *errorcodeptr = ERR39;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 39			; 00000027H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN695@compile_br:

; 4453 :             {
; 4454 :             *errorcodeptr = ERR38;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 38			; 00000026H

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN697@compile_br:

; 4497 :               {
; 4498 :               *errorcodeptr = ERR42;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 42			; 0000002aH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN698@compile_br:

; 4502 :               {
; 4503 :               *errorcodeptr = ERR49;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 49			; 00000031H

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN701@compile_br:

; 4669 :             {
; 4670 :             *errorcodeptr = ERR29;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 29			; 0000001dH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN704@compile_br:

; 4691 :               {
; 4692 :               *errorcodeptr = ERR58;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 58			; 0000003aH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN63@compile_br:

; 4791 : 
; 4792 :             default:  *errorcodeptr = ERR12;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	sub	edi, 1
	mov	DWORD PTR [eax], 12			; 0000000cH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN706@compile_br:

; 4943 :           {
; 4944 :           *errorcodeptr = ERR54;

	mov	DWORD PTR [ebx], 54			; 00000036H

; 4945 :           goto FAILED;

	jmp	$LN789@compile_br
$LN707@compile_br:

; 4957 :           {
; 4958 :           *errorcodeptr = ERR27;

	mov	DWORD PTR [ebx], 27			; 0000001bH

; 4959 :           goto FAILED;

	jmp	$LN789@compile_br
$LN708@compile_br:

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ebx], 14			; 0000000eH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN709@compile_br:

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ebx], 20			; 00000014H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN711@compile_br:

; 4582 :             {
; 4583 :             *errorcodeptr = ERR62;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 62			; 0000003eH

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN712@compile_br:

; 4587 :             {
; 4588 :             *errorcodeptr = ERR42;

	mov	edx, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [edx], 42			; 0000002aH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN713@compile_br:

; 4592 :             {
; 4593 :             *errorcodeptr = ERR48;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [eax], 48			; 00000030H
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
$LN714@compile_br:

; 4622 :             {
; 4623 :             *errorcodeptr = ERR15;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [ecx], 15			; 0000000fH

; 4624 :             goto FAILED;

	jmp	$LN789@compile_br
$LN716@compile_br:

; 4737 :               {
; 4738 :               *errorcodeptr = ERR40;

	mov	eax, DWORD PTR _errorcodeptr$[esp+212]
	mov	DWORD PTR [eax], 40			; 00000028H

; 4739 :               goto FAILED;

	jmp	$LN789@compile_br
$LN717@compile_br:

; 5234 :       }
; 5235 : 
; 5236 :     break;            /* End of literal character handling */
; 5237 :     }
; 5238 :   }                   /* end of big loop */
; 5239 : 
; 5240 : 
; 5241 : /* Control never reaches here by falling through, only by a goto for all the
; 5242 : error states. Pass back the position in the pattern so that it can be displayed
; 5243 : to the user for diagnosing the error. */
; 5244 : 
; 5245 : FAILED:
; 5246 : *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptrptr$[esp+212]
	mov	DWORD PTR [esi], 45			; 0000002dH
	mov	DWORD PTR [ecx], edi
	pop	edi
	pop	esi
	pop	ebp

; 5247 : return FALSE;

	xor	eax, eax
	pop	ebx

; 5248 : }

	add	esp, 200				; 000000c8H
	ret	0
	npad	3
$LN886@compile_br:
	DD	$LN508@compile_br
	DD	$LN502@compile_br
	DD	$LN220@compile_br
	DD	$LN340@compile_br
	DD	$LN339@compile_br
	DD	$LN501@compile_br
	DD	$LN338@compile_br
	DD	$LN499@compile_br
	DD	$LN31@compile_br
	DD	$LN505@compile_br
	DD	$LN343@compile_br
	DD	$NORMAL_CHAR$6043
$LN767@compile_br:
	DB	0
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	1
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	2
	DB	0
	DB	3
	DB	4
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	5
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	6
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	7
	DB	8
	DB	11					; 0000000bH
	DB	9
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	11					; 0000000bH
	DB	10					; 0000000aH
	DB	0
	npad	3
$LN887@compile_br:
	DD	$LN432@compile_br
	DD	$LN436@compile_br
	DD	$LN416@compile_br
	DD	$LN420@compile_br
	DD	$LN424@compile_br
	DD	$LN428@compile_br
$LN888@compile_br:
	DD	$LN233@compile_br
	DD	$LN232@compile_br
	DD	$LN231@compile_br
	DD	$LN230@compile_br
	DD	$LN225@compile_br
	DD	$LN224@compile_br
	DD	$LN223@compile_br
	DD	$LN222@compile_br
	DD	$LN229@compile_br
	DD	$LN228@compile_br
	DD	$LN227@compile_br
	DD	$LN226@compile_br
	DD	$LN221@compile_br
$LN768@compile_br:
	DB	0
	DB	12					; 0000000cH
	DB	1
	DB	12					; 0000000cH
	DB	2
	DB	12					; 0000000cH
	DB	3
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	4
	DB	12					; 0000000cH
	DB	5
	DB	12					; 0000000cH
	DB	6
	DB	12					; 0000000cH
	DB	7
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	12					; 0000000cH
	DB	8
	DB	12					; 0000000cH
	DB	9
	DB	12					; 0000000cH
	DB	10					; 0000000aH
	DB	12					; 0000000cH
	DB	11					; 0000000bH
	npad	3
$LN889@compile_br:
	DD	$LN153@compile_br
	DD	$LN204@compile_br
	DD	$LN116@compile_br
	DD	$DEFINE_NAME$6534
	DD	$LN198@compile_br
	DD	$LN98@compile_br
	DD	$LN199@compile_br
	DD	$LN151@compile_br
	DD	$LN154@compile_br
	DD	$LN144@compile_br
	DD	$LN143@compile_br
	DD	$LN138@compile_br
	DD	$LN100@compile_br
	DD	$LN200@compile_br
	DD	$OTHER_CHAR_AFTER_QUERY$6602
$LN769@compile_br:
	DB	0
	DB	14					; 0000000eH
	DB	1
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	2
	DB	3
	DB	4
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	5
	DB	14					; 0000000eH
	DB	5
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	5
	DB	6
	DB	14					; 0000000eH
	DB	7
	DB	8
	DB	9
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	10					; 0000000aH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	11					; 0000000bH
	DB	14					; 0000000eH
	DB	12					; 0000000cH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	14					; 0000000eH
	DB	13					; 0000000dH
$LN890@compile_br:
	DD	$LN71@compile_br
	DD	$LN70@compile_br
	DD	$LN65@compile_br
	DD	$LN64@compile_br
	DD	$LN69@compile_br
	DD	$LN68@compile_br
	DD	$LN67@compile_br
	DD	$LN66@compile_br
	DD	$LN63@compile_br
$LN770@compile_br:
	DB	0
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	1
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	2
	DB	8
	DB	8
	DB	3
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	4
	DB	8
	DB	8
	DB	8
	DB	5
	DB	8
	DB	8
	DB	8
	DB	8
	DB	8
	DB	6
	DB	8
	DB	8
	DB	8
	DB	8
	DB	7
_compile_branch ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _compile_regex
_TEXT	SEGMENT
_code$ = -48						; size = 4
_ptr$ = -44						; size = 4
_branchreqbyte$ = -40					; size = 4
_last_branch$ = -36					; size = 4
_firstbyte$ = -32					; size = 4
_max_bracount$ = -28					; size = 4
_branchfirstbyte$ = -24					; size = 4
_reverse_count$ = -20					; size = 4
_orig_bracount$ = -16					; size = 4
_start_bracket$ = -12					; size = 4
_bc$ = -8						; size = 8
_options$ = 8						; size = 4
_oldims$ = 12						; size = 4
_codeptr$ = 16						; size = 4
_ptrptr$ = 20						; size = 4
_errorcodeptr$ = 24					; size = 4
_lookbehind$ = 28					; size = 4
_reset_bracount$ = 32					; size = 4
_skipbytes$ = 36					; size = 4
_firstbyteptr$ = 40					; size = 4
_reqbyteptr$ = 44					; size = 4
_length$ = 48						; size = 4
_bcptr$ = 48						; size = 4
_cd$ = 52						; size = 4
_lengthptr$ = 56					; size = 4
_compile_regex PROC					; COMDAT

; 5293 : {

	sub	esp, 48					; 00000030H

; 5294 : const uschar *ptr = *ptrptr;

	mov	eax, DWORD PTR _ptrptr$[esp+44]
	mov	ecx, DWORD PTR [eax]

; 5295 : uschar *code = *codeptr;
; 5296 : uschar *last_branch = code;
; 5297 : uschar *start_bracket = code;
; 5298 : uschar *reverse_count = NULL;
; 5299 : int firstbyte, reqbyte;
; 5300 : int branchfirstbyte, branchreqbyte;
; 5301 : int length;
; 5302 : int orig_bracount;
; 5303 : int max_bracount;
; 5304 : branch_chain bc;
; 5305 : 
; 5306 : bc.outer = bcptr;

	mov	eax, DWORD PTR _bcptr$[esp+44]
	mov	edx, DWORD PTR _codeptr$[esp+44]
	push	ebx
	mov	ebx, DWORD PTR [edx]
	mov	DWORD PTR _bc$[esp+52], eax

; 5307 : bc.current = code;
; 5308 : 
; 5309 : firstbyte = reqbyte = REQ_UNSET;
; 5310 : 
; 5311 : /* Accumulate the length for use in the pre-compile phase. Start with the
; 5312 : length of the BRA and KET and any extra bytes that are required at the
; 5313 : beginning. We accumulate in a local variable to save frequent testing of
; 5314 : lenthptr for NULL. We cannot do this by looking at the value of code at the
; 5315 : start and end of each alternative, because compiled items are discarded during
; 5316 : the pre-compile phase so that the work space is not exceeded. */
; 5317 : 
; 5318 : length = 2 + 2*LINK_SIZE + skipbytes;

	mov	eax, DWORD PTR _skipbytes$[esp+48]
	push	ebp
	push	esi

; 5357 :     }
; 5358 : 
; 5359 :   /* Now compile the branch; in the pre-compile phase its length gets added
; 5360 :   into the length. */
; 5361 : 
; 5362 :   if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
; 5363 :         &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))

	mov	esi, DWORD PTR _lengthptr$[esp+56]
	mov	DWORD PTR _ptr$[esp+60], ecx
	lea	ecx, DWORD PTR [eax+6]
	mov	DWORD PTR _bc$[esp+64], ebx
	mov	DWORD PTR _length$[esp+56], ecx
	mov	BYTE PTR [ebx+1], 0
	push	edi
	mov	edi, DWORD PTR _cd$[esp+60]
	mov	BYTE PTR [ebx+2], 0
	neg	esi
	mov	DWORD PTR _last_branch$[esp+64], ebx
	mov	DWORD PTR _start_bracket$[esp+64], ebx
	lea	ebx, DWORD PTR [ebx+eax+3]
	mov	eax, DWORD PTR [edi+48]
	mov	ebp, -2					; fffffffeH
	sbb	esi, esi
	lea	edx, DWORD PTR _length$[esp+60]
	mov	DWORD PTR _reverse_count$[esp+64], 0
	mov	DWORD PTR _firstbyte$[esp+64], ebp
	mov	DWORD PTR _max_bracount$[esp+64], eax
	mov	DWORD PTR _orig_bracount$[esp+64], eax
	and	esi, edx
$LN44@compile_re:
	cmp	DWORD PTR _reset_bracount$[esp+60], 0
	mov	DWORD PTR _code$[esp+64], ebx
	je	SHORT $LN25@compile_re
	mov	eax, DWORD PTR _orig_bracount$[esp+64]
	mov	DWORD PTR [edi+48], eax
$LN25@compile_re:
	mov	eax, DWORD PTR _options$[esp+60]
	mov	ecx, eax
	and	ecx, 7
	cmp	ecx, DWORD PTR _oldims$[esp+60]
	je	SHORT $LN40@compile_re
	mov	BYTE PTR [ebx], 24			; 00000018H
	add	ebx, 1
	and	al, 7
	mov	BYTE PTR [ebx], al
	add	ebx, 1
	add	DWORD PTR _length$[esp+60], 2
	mov	DWORD PTR _code$[esp+64], ebx
$LN40@compile_re:

; 5319 : 
; 5320 : /* WARNING: If the above line is changed for any reason, you must also change
; 5321 : the code that abstracts option settings at the start of the pattern and makes
; 5322 : them global. It tests the value of length for (2 + 2*LINK_SIZE) in the
; 5323 : pre-compile phase to find out whether anything has yet been compiled or not. */
; 5324 : 
; 5325 : /* Offset is set zero to mark that this bracket is still open */
; 5326 : 
; 5327 : PUT(code, 1, 0);
; 5328 : code += 1 + LINK_SIZE + skipbytes;
; 5329 : 
; 5330 : /* Loop for each alternative branch */
; 5331 : 
; 5332 : orig_bracount = max_bracount = cd->bracount;
; 5333 : for (;;)
; 5334 :   {
; 5335 :   /* For a (?| group, reset the capturing bracket count so that each branch
; 5336 :   uses the same numbers. */
; 5337 : 
; 5338 :   if (reset_bracount) cd->bracount = orig_bracount;
; 5339 : 
; 5340 :   /* Handle a change of ims options at the start of the branch */
; 5341 : 
; 5342 :   if ((options & PCRE_IMS) != oldims)
; 5343 :     {
; 5344 :     *code++ = OP_OPT;
; 5345 :     *code++ = options & PCRE_IMS;
; 5346 :     length += 2;
; 5347 :     }
; 5348 : 
; 5349 :   /* Set up dummy OP_REVERSE if lookbehind assertion */
; 5350 : 
; 5351 :   if (lookbehind)

	cmp	DWORD PTR _lookbehind$[esp+60], 0
	je	SHORT $LN23@compile_re

; 5352 :     {
; 5353 :     *code++ = OP_REVERSE;

	mov	BYTE PTR [ebx], 91			; 0000005bH
	add	ebx, 1

; 5354 :     reverse_count = code;
; 5355 :     PUTINC(code, 0, 0);

	mov	BYTE PTR [ebx], 0
	mov	BYTE PTR [ebx+1], 0
	mov	DWORD PTR _reverse_count$[esp+64], ebx
	add	ebx, 2

; 5356 :     length += 1 + LINK_SIZE;

	add	DWORD PTR _length$[esp+60], 3
	mov	DWORD PTR _code$[esp+64], ebx
$LN23@compile_re:

; 5357 :     }
; 5358 : 
; 5359 :   /* Now compile the branch; in the pre-compile phase its length gets added
; 5360 :   into the length. */
; 5361 : 
; 5362 :   if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
; 5363 :         &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))

	push	esi
	push	edi
	lea	edx, DWORD PTR _bc$[esp+72]
	push	edx
	mov	edx, DWORD PTR _errorcodeptr$[esp+72]
	lea	eax, DWORD PTR _branchreqbyte$[esp+76]
	push	eax
	lea	ecx, DWORD PTR _branchfirstbyte$[esp+80]
	push	ecx
	push	edx
	lea	eax, DWORD PTR _ptr$[esp+88]
	push	eax
	lea	ecx, DWORD PTR _code$[esp+92]
	push	ecx
	lea	edx, DWORD PTR _options$[esp+92]
	push	edx
	call	_compile_branch
	add	esp, 36					; 00000024H
	test	eax, eax
	je	$LN33@compile_re

; 5367 :     }
; 5368 : 
; 5369 :   /* Keep the highest bracket count in case (?| was used and some branch
; 5370 :   has fewer than the rest. */
; 5371 : 
; 5372 :   if (cd->bracount > max_bracount) max_bracount = cd->bracount;

	mov	eax, DWORD PTR [edi+48]
	cmp	eax, DWORD PTR _max_bracount$[esp+64]
	jle	SHORT $LN21@compile_re
	mov	DWORD PTR _max_bracount$[esp+64], eax
$LN21@compile_re:

; 5373 : 
; 5374 :   /* In the real compile phase, there is some post-processing to be done. */
; 5375 : 
; 5376 :   if (lengthptr == NULL)

	cmp	DWORD PTR _lengthptr$[esp+60], 0
	mov	ebx, DWORD PTR _code$[esp+64]

; 5377 :     {
; 5378 :     /* If this is the first branch, the firstbyte and reqbyte values for the
; 5379 :     branch become the values for the regex. */
; 5380 : 
; 5381 :     if (*last_branch != OP_ALT)

	mov	ecx, DWORD PTR _last_branch$[esp+64]
	jne	$LN12@compile_re
	cmp	BYTE PTR [ecx], 83			; 00000053H
	je	SHORT $LN19@compile_re

; 5382 :       {
; 5383 :       firstbyte = branchfirstbyte;

	mov	eax, DWORD PTR _branchfirstbyte$[esp+64]

; 5384 :       reqbyte = branchreqbyte;

	mov	ebp, DWORD PTR _branchreqbyte$[esp+64]
	mov	DWORD PTR _firstbyte$[esp+64], eax

; 5385 :       }
; 5386 : 
; 5387 :     /* If this is not the first branch, the first char and reqbyte have to
; 5388 :     match the values from all the previous branches, except that if the
; 5389 :     previous value for reqbyte didn't have REQ_VARY set, it can still match,
; 5390 :     and we set REQ_VARY for the regex. */
; 5391 : 
; 5392 :     else

	jmp	SHORT $LN13@compile_re
$LN19@compile_re:

; 5393 :       {
; 5394 :       /* If we previously had a firstbyte, but it doesn't match the new branch,
; 5395 :       we have to abandon the firstbyte for the regex, but if there was
; 5396 :       previously no reqbyte, it takes on the value of the old firstbyte. */
; 5397 : 
; 5398 :       if (firstbyte >= 0 && firstbyte != branchfirstbyte)

	mov	eax, DWORD PTR _firstbyte$[esp+64]
	test	eax, eax
	mov	edx, DWORD PTR _branchfirstbyte$[esp+64]
	jl	SHORT $LN41@compile_re
	cmp	eax, edx
	je	SHORT $LN42@compile_re

; 5399 :         {
; 5400 :         if (reqbyte < 0) reqbyte = firstbyte;

	test	ebp, ebp
	jge	SHORT $LN16@compile_re
	mov	ebp, eax
$LN16@compile_re:

; 5401 :         firstbyte = REQ_NONE;

	mov	DWORD PTR _firstbyte$[esp+64], -1
$LN41@compile_re:

; 5402 :         }
; 5403 : 
; 5404 :       /* If we (now or from before) have no firstbyte, a firstbyte from the
; 5405 :       branch becomes a reqbyte if there isn't a branch reqbyte. */
; 5406 : 
; 5407 :       if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)

	test	edx, edx
	jl	SHORT $LN42@compile_re
	mov	eax, DWORD PTR _branchreqbyte$[esp+64]
	test	eax, eax
	jge	SHORT $LN15@compile_re

; 5408 :           branchreqbyte = branchfirstbyte;

	mov	eax, edx
	mov	DWORD PTR _branchreqbyte$[esp+64], eax
	jmp	SHORT $LN15@compile_re
$LN42@compile_re:
	mov	eax, DWORD PTR _branchreqbyte$[esp+64]
$LN15@compile_re:

; 5409 : 
; 5410 :       /* Now ensure that the reqbytes match */
; 5411 : 
; 5412 :       if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))

	mov	edx, eax
	xor	edx, ebp
	test	edx, -513				; fffffdffH
	je	SHORT $LN14@compile_re

; 5413 :         reqbyte = REQ_NONE;

	or	ebp, -1
	jmp	SHORT $LN13@compile_re
$LN14@compile_re:

; 5414 :       else reqbyte |= branchreqbyte;   /* To "or" REQ_VARY */

	or	ebp, eax
$LN13@compile_re:

; 5415 :       }
; 5416 : 
; 5417 :     /* If lookbehind, check that this branch matches a fixed-length string, and
; 5418 :     put the length into the OP_REVERSE item. Temporarily mark the end of the
; 5419 :     branch with OP_END. */
; 5420 : 
; 5421 :     if (lookbehind)

	cmp	DWORD PTR _lookbehind$[esp+60], 0
	je	SHORT $LN12@compile_re

; 5422 :       {
; 5423 :       int fixed_length;
; 5424 :       *code = OP_END;
; 5425 :       fixed_length = find_fixedlength(last_branch, options);

	mov	eax, DWORD PTR _options$[esp+60]
	push	eax
	push	ecx
	mov	BYTE PTR [ebx], 0
	call	_find_fixedlength
	add	esp, 8

; 5426 :       DPRINTF(("fixed length = %d\n", fixed_length));
; 5427 :       if (fixed_length < 0)

	test	eax, eax
	jl	$LN34@compile_re

; 5432 :         }
; 5433 :       PUT(reverse_count, 0, fixed_length);

	mov	edi, DWORD PTR _reverse_count$[esp+64]
	mov	ecx, eax
	sar	ecx, 8
	mov	BYTE PTR [edi], cl
	mov	ecx, DWORD PTR _last_branch$[esp+64]
	mov	BYTE PTR [edi+1], al
$LN12@compile_re:

; 5434 :       }
; 5435 :     }
; 5436 : 
; 5437 :   /* Reached end of expression, either ')' or end of pattern. In the real
; 5438 :   compile phase, go back through the alternative branches and reverse the chain
; 5439 :   of offsets, with the field in the BRA item now becoming an offset to the
; 5440 :   first alternative. If there are no alternatives, it points to the end of the
; 5441 :   group. The length in the terminating ket is always the length of the whole
; 5442 :   bracketed item. If any of the ims options were changed inside the group,
; 5443 :   compile a resetting op-code following, except at the very end of the pattern.
; 5444 :   Return leaving the pointer at the terminating char. */
; 5445 : 
; 5446 :   if (*ptr != '|')

	mov	edi, DWORD PTR _ptr$[esp+64]
	cmp	BYTE PTR [edi], 124			; 0000007cH
	jne	$LN35@compile_re

; 5496 :     }
; 5497 : 
; 5498 :   /* Another branch follows. In the pre-compile phase, we can move the code
; 5499 :   pointer back to where it was for the start of the first branch. (That is,
; 5500 :   pretend that each branch is the only one.)
; 5501 : 
; 5502 :   In the real compile phase, insert an ALT node. Its length field points back
; 5503 :   to the previous branch while the bracket remains open. At the end the chain
; 5504 :   is reversed. It's done like this so that the start of the bracket has a
; 5505 :   zero offset until it is closed, making it possible to detect recursion. */
; 5506 : 
; 5507 :   if (lengthptr != NULL)

	cmp	DWORD PTR _lengthptr$[esp+60], 0
	je	SHORT $LN2@compile_re

; 5508 :     {
; 5509 :     code = *codeptr + 1 + LINK_SIZE + skipbytes;

	mov	edx, DWORD PTR _codeptr$[esp+60]

; 5510 :     length += 1 + LINK_SIZE;

	add	DWORD PTR _length$[esp+60], 3
	mov	eax, DWORD PTR [edx]
	mov	ecx, DWORD PTR _skipbytes$[esp+60]

; 5518 :     }
; 5519 : 
; 5520 :   ptr++;

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+64], edi

; 5521 :   }

	mov	edi, DWORD PTR _cd$[esp+60]
	lea	ebx, DWORD PTR [eax+ecx+3]
	jmp	$LN44@compile_re
$LN2@compile_re:

; 5511 :     }
; 5512 :   else
; 5513 :     {
; 5514 :     *code = OP_ALT;
; 5515 :     PUT(code, 1, code - last_branch);

	mov	edx, ebx
	sub	edx, ecx
	mov	BYTE PTR [ebx], 83			; 00000053H
	mov	al, bl
	sar	edx, 8
	mov	BYTE PTR [ebx+1], dl
	sub	al, cl
	mov	BYTE PTR [ebx+2], al

; 5516 :     bc.current = last_branch = code;

	mov	DWORD PTR _last_branch$[esp+64], ebx
	mov	DWORD PTR _bc$[esp+68], ebx

; 5517 :     code += 1 + LINK_SIZE;

	add	ebx, 3

; 5518 :     }
; 5519 : 
; 5520 :   ptr++;

	add	edi, 1
	mov	DWORD PTR _ptr$[esp+64], edi

; 5521 :   }

	mov	edi, DWORD PTR _cd$[esp+60]
	jmp	$LN44@compile_re
$LN33@compile_re:

; 5364 :     {
; 5365 :     *ptrptr = ptr;

	mov	ecx, DWORD PTR _ptr$[esp+64]
	mov	edx, DWORD PTR _ptrptr$[esp+60]
	pop	edi
	pop	esi
	pop	ebp
	mov	DWORD PTR [edx], ecx

; 5366 :     return FALSE;

	xor	eax, eax
	pop	ebx

; 5522 : /* Control never reaches here */
; 5523 : }

	add	esp, 48					; 00000030H
	ret	0
$LN34@compile_re:

; 5428 :         {
; 5429 :         *errorcodeptr = (fixed_length == -2)? ERR36 : ERR25;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+60]

; 5430 :         *ptrptr = ptr;

	mov	edx, DWORD PTR _ptr$[esp+64]
	sub	eax, -2					; fffffffeH
	neg	eax
	sbb	eax, eax
	and	eax, -11				; fffffff5H
	add	eax, 36					; 00000024H
	pop	edi
	mov	DWORD PTR [ecx], eax
	mov	eax, DWORD PTR _ptrptr$[esp+56]
	pop	esi
	pop	ebp
	mov	DWORD PTR [eax], edx

; 5431 :         return FALSE;

	xor	eax, eax
	pop	ebx

; 5522 : /* Control never reaches here */
; 5523 : }

	add	esp, 48					; 00000030H
	ret	0
$LN35@compile_re:

; 5447 :     {
; 5448 :     if (lengthptr == NULL)

	mov	esi, DWORD PTR _lengthptr$[esp+60]
	test	esi, esi
	jne	SHORT $LN6@compile_re

; 5449 :       {
; 5450 :       int branch_length = code - last_branch;

	mov	eax, ebx
	sub	eax, ecx
	npad	5
$LL8@compile_re:

; 5451 :       do
; 5452 :         {
; 5453 :         int prev_length = GET(last_branch, 1);

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

; 5454 :         PUT(last_branch, 1, branch_length);

	mov	BYTE PTR [ecx+2], al
	mov	esi, edx
	mov	edx, eax
	sar	edx, 8
	mov	BYTE PTR [ecx+1], dl

; 5455 :         branch_length = prev_length;
; 5456 :         last_branch -= branch_length;

	sub	ecx, esi

; 5457 :         }
; 5458 :       while (branch_length > 0);

	test	esi, esi
	mov	eax, esi
	jg	SHORT $LL8@compile_re
	mov	esi, DWORD PTR _lengthptr$[esp+60]
$LN6@compile_re:

; 5459 :       }
; 5460 : 
; 5461 :     /* Fill in the ket */
; 5462 : 
; 5463 :     *code = OP_KET;
; 5464 :     PUT(code, 1, code - start_bracket);

	mov	eax, DWORD PTR _start_bracket$[esp+64]
	mov	ecx, ebx
	sub	ecx, eax
	mov	dl, bl
	sub	dl, al

; 5465 :     code += 1 + LINK_SIZE;
; 5466 : 
; 5467 :     /* Resetting option if needed */
; 5468 : 
; 5469 :     if ((options & PCRE_IMS) != oldims && *ptr == ')')

	mov	eax, DWORD PTR _options$[esp+60]
	sar	ecx, 8
	mov	BYTE PTR [ebx], 84			; 00000054H
	mov	BYTE PTR [ebx+1], cl
	mov	ecx, DWORD PTR _oldims$[esp+60]
	mov	BYTE PTR [ebx+2], dl
	and	eax, 7
	add	ebx, 3
	cmp	eax, ecx
	je	SHORT $LN38@compile_re
	cmp	BYTE PTR [edi], 41			; 00000029H
	jne	SHORT $LN38@compile_re

; 5470 :       {
; 5471 :       *code++ = OP_OPT;

	mov	BYTE PTR [ebx], 24			; 00000018H
	add	ebx, 1

; 5472 :       *code++ = oldims;

	mov	BYTE PTR [ebx], cl

; 5473 :       length += 2;

	mov	ecx, DWORD PTR _length$[esp+60]
	add	ebx, 1
	add	ecx, 2
	jmp	SHORT $LN5@compile_re
$LN38@compile_re:
	mov	ecx, DWORD PTR _length$[esp+60]
$LN5@compile_re:

; 5474 :       }
; 5475 : 
; 5476 :     /* Retain the highest bracket number, in case resetting was used. */
; 5477 : 
; 5478 :     cd->bracount = max_bracount;
; 5479 : 
; 5480 :     /* Set values to pass back */
; 5481 : 
; 5482 :     *codeptr = code;
; 5483 :     *ptrptr = ptr;
; 5484 :     *firstbyteptr = firstbyte;
; 5485 :     *reqbyteptr = reqbyte;
; 5486 :     if (lengthptr != NULL)

	test	esi, esi
	mov	eax, DWORD PTR _max_bracount$[esp+64]
	mov	edx, DWORD PTR _cd$[esp+60]
	mov	DWORD PTR [edx+48], eax
	mov	eax, DWORD PTR _codeptr$[esp+60]
	mov	edx, DWORD PTR _ptrptr$[esp+60]
	mov	DWORD PTR [eax], ebx
	mov	eax, DWORD PTR _firstbyteptr$[esp+60]
	mov	DWORD PTR [edx], edi
	mov	edx, DWORD PTR _firstbyte$[esp+64]
	mov	DWORD PTR [eax], edx
	mov	eax, DWORD PTR _reqbyteptr$[esp+60]
	mov	DWORD PTR [eax], ebp
	je	SHORT $LN4@compile_re

; 5487 :       {
; 5488 :       if (OFLOW_MAX - *lengthptr < length)

	mov	eax, DWORD PTR [esi]
	mov	edx, 2147483627				; 7fffffebH
	sub	edx, eax
	cmp	edx, ecx
	jge	SHORT $LN3@compile_re

; 5489 :         {
; 5490 :         *errorcodeptr = ERR20;

	mov	eax, DWORD PTR _errorcodeptr$[esp+60]
	pop	edi
	pop	esi
	pop	ebp
	mov	DWORD PTR [eax], 20			; 00000014H

; 5491 :         return FALSE;

	xor	eax, eax
	pop	ebx

; 5522 : /* Control never reaches here */
; 5523 : }

	add	esp, 48					; 00000030H
	ret	0
$LN3@compile_re:

; 5492 :         }
; 5493 :       *lengthptr += length;

	add	eax, ecx
	mov	DWORD PTR [esi], eax
$LN4@compile_re:
	pop	edi
	pop	esi
	pop	ebp

; 5494 :       }
; 5495 :     return TRUE;

	mov	eax, 1
	pop	ebx

; 5522 : /* Control never reaches here */
; 5523 : }

	add	esp, 48					; 00000030H
	ret	0
_compile_regex ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _is_anchored
_TEXT	SEGMENT
_code$ = 8						; size = 4
_options$ = 12						; size = 4
_bracket_map$ = 16					; size = 4
_backref_map$ = 20					; size = 4
_is_anchored PROC					; COMDAT

; 5569 : {

	push	ebx
	push	ebp
	mov	ebp, DWORD PTR _code$[esp+4]
	push	esi
	push	edi
	mov	edi, DWORD PTR _options$[esp+12]
	npad	4
$LL20@is_anchore:

; 5570 : do {
; 5571 :    const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
; 5572 :      options, PCRE_MULTILINE, FALSE);

	movzx	eax, BYTE PTR [ebp]
	movzx	eax, BYTE PTR __pcre_OP_lengths[eax]
	xor	ebx, ebx
	add	eax, ebp
	lea	esi, DWORD PTR [ebx+2]
	call	_first_significant_code

; 5573 :    register int op = *scode;

	movzx	ecx, BYTE PTR [eax]

; 5574 : 
; 5575 :    /* Non-capturing brackets */
; 5576 : 
; 5577 :    if (op == OP_BRA)

	cmp	ecx, 93					; 0000005dH

; 5580 :      }
; 5581 : 
; 5582 :    /* Capturing brackets */
; 5583 : 
; 5584 :    else if (op == OP_CBRA)

	je	SHORT $LN10@is_anchore
	cmp	ecx, 94					; 0000005eH
	jne	SHORT $LN14@is_anchore

; 5585 :      {
; 5586 :      int n = GET2(scode, 1+LINK_SIZE);

	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+3]

; 5587 :      int new_map = bracket_map | ((n < 32)? (1 << n) : 1);

	lea	edx, DWORD PTR [ebx+1]
	mov	cl, BYTE PTR [eax+4]
	cmp	ecx, 32					; 00000020H
	jge	SHORT $LN24@is_anchore
	shl	edx, cl
$LN24@is_anchore:
	or	edx, DWORD PTR _bracket_map$[esp+12]

; 5588 :      if (!is_anchored(scode, options, new_map, backref_map)) return FALSE;
; 5589 :      }
; 5590 : 
; 5591 :    /* Other brackets */
; 5592 : 
; 5593 :    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)

	jmp	SHORT $LN33@is_anchore
$LN14@is_anchore:
	cmp	ecx, 87					; 00000057H
	je	SHORT $LN10@is_anchore
	cmp	ecx, 92					; 0000005cH
	je	SHORT $LN10@is_anchore
	cmp	ecx, 95					; 0000005fH
	je	SHORT $LN10@is_anchore

; 5596 :      }
; 5597 : 
; 5598 :    /* .* is not anchored unless DOTALL is set and it isn't in brackets that
; 5599 :    are or may be referenced. */
; 5600 : 
; 5601 :    else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
; 5602 :              op == OP_TYPEPOSSTAR) &&
; 5603 :             (*options & PCRE_DOTALL) != 0)

	cmp	ecx, 56					; 00000038H
	je	SHORT $LN6@is_anchore
	cmp	ecx, 57					; 00000039H
	je	SHORT $LN6@is_anchore
	cmp	ecx, 65					; 00000041H
	jne	SHORT $LN7@is_anchore
$LN6@is_anchore:
	test	BYTE PTR [edi], 4
	je	SHORT $LN7@is_anchore

; 5604 :      {
; 5605 :      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;

	cmp	BYTE PTR [eax+1], 12			; 0000000cH
	jne	SHORT $LN26@is_anchore
	mov	edx, DWORD PTR _backref_map$[esp+12]
	test	DWORD PTR _bracket_map$[esp+12], edx
	je	SHORT $LN31@is_anchore
$LN26@is_anchore:
	pop	edi
	pop	esi
	pop	ebp

; 5578 :      {
; 5579 :      if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;

	xor	eax, eax
	pop	ebx

; 5617 : }

	ret	0
$LN7@is_anchore:

; 5606 :      }
; 5607 : 
; 5608 :    /* Check for explicit anchoring */
; 5609 : 
; 5610 :    else if (op != OP_SOD && op != OP_SOM &&
; 5611 :            ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))

	cmp	ecx, 1
	je	SHORT $LN31@is_anchore
	cmp	ecx, esi
	je	SHORT $LN31@is_anchore
	test	BYTE PTR [edi], 2
	jne	SHORT $LN26@is_anchore
	cmp	ecx, 25					; 00000019H
	jne	SHORT $LN26@is_anchore
	jmp	SHORT $LN31@is_anchore
$LN10@is_anchore:

; 5594 :      {
; 5595 :      if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;

	mov	edx, DWORD PTR _bracket_map$[esp+12]
$LN33@is_anchore:
	mov	ecx, DWORD PTR _backref_map$[esp+12]
	push	ecx
	push	edx
	push	edi
	push	eax
	call	_is_anchored
	add	esp, 16					; 00000010H
	test	eax, eax
	je	SHORT $LN26@is_anchore
$LN31@is_anchore:

; 5612 :      return FALSE;
; 5613 :    code += GET(code, 1);

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

; 5614 :    }
; 5615 : while (*code == OP_ALT);   /* Loop for each alternative */

	cmp	BYTE PTR [ebp], 83			; 00000053H
	je	$LL20@is_anchore
	pop	edi
	pop	esi
	pop	ebp

; 5616 : return TRUE;

	mov	eax, 1
	pop	ebx

; 5617 : }

	ret	0
_is_anchored ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _is_startline
_TEXT	SEGMENT
_code$ = 8						; size = 4
_bracket_map$ = 12					; size = 4
_backref_map$ = 16					; size = 4
_is_startline PROC					; COMDAT

; 5645 : {

	push	ebp
	mov	ebp, DWORD PTR _bracket_map$[esp]
	push	esi
	mov	esi, DWORD PTR _code$[esp+4]
	push	edi
	mov	edi, DWORD PTR _backref_map$[esp+8]
	npad	1
$LL19@is_startli:

; 5646 : do {
; 5647 :    const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
; 5648 :      NULL, 0, FALSE);

	movzx	eax, BYTE PTR [esi]
	movzx	eax, BYTE PTR __pcre_OP_lengths[eax]
	movzx	edx, BYTE PTR [eax+esi]
	add	eax, esi
	mov	ecx, edx
	sub	ecx, 4
	cmp	ecx, 97					; 00000061H
	ja	SHORT $LN32@is_startli
	npad	6
$LL38@is_startli:
	movzx	ecx, BYTE PTR $LN49@is_startli[ecx]
	jmp	DWORD PTR $LN52@is_startli[ecx*4]
$LN34@is_startli:
	add	eax, 2
	jmp	SHORT $LN35@is_startli
$LN26@is_startli:
	movzx	edx, BYTE PTR __pcre_OP_lengths[edx]
	add	eax, edx
$LN35@is_startli:
	movzx	edx, BYTE PTR [eax]
	mov	ecx, edx
	sub	ecx, 4
	cmp	ecx, 97					; 00000061H
	jbe	SHORT $LL38@is_startli
$LN32@is_startli:

; 5649 :    register int op = *scode;

	movzx	ecx, BYTE PTR [eax]

; 5650 : 
; 5651 :    /* Non-capturing brackets */
; 5652 : 
; 5653 :    if (op == OP_BRA)

	cmp	ecx, 93					; 0000005dH

; 5656 :      }
; 5657 : 
; 5658 :    /* Capturing brackets */
; 5659 : 
; 5660 :    else if (op == OP_CBRA)

	je	SHORT $LN9@is_startli
	cmp	ecx, 94					; 0000005eH
	jne	SHORT $LN13@is_startli

; 5661 :      {
; 5662 :      int n = GET2(scode, 1+LINK_SIZE);

	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+3]

; 5663 :      int new_map = bracket_map | ((n < 32)? (1 << n) : 1);

	mov	edx, 1
	mov	cl, BYTE PTR [eax+4]
	cmp	ecx, 32					; 00000020H
	jge	SHORT $LN23@is_startli
	shl	edx, cl
$LN23@is_startli:

; 5664 :      if (!is_startline(scode, new_map, backref_map)) return FALSE;

	push	edi
	or	edx, ebp
	push	edx

; 5665 :      }
; 5666 : 
; 5667 :    /* Other brackets */
; 5668 : 
; 5669 :    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)

	jmp	SHORT $LN51@is_startli
$LN13@is_startli:
	cmp	ecx, 87					; 00000057H
	je	SHORT $LN9@is_startli
	cmp	ecx, 92					; 0000005cH
	je	SHORT $LN9@is_startli
	cmp	ecx, 95					; 0000005fH
	je	SHORT $LN9@is_startli

; 5671 : 
; 5672 :    /* .* means "start at start or after \n" if it isn't in brackets that
; 5673 :    may be referenced. */
; 5674 : 
; 5675 :    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)

	cmp	ecx, 56					; 00000038H
	je	SHORT $LN5@is_startli
	cmp	ecx, 57					; 00000039H
	je	SHORT $LN5@is_startli
	cmp	ecx, 65					; 00000041H
	je	SHORT $LN5@is_startli

; 5678 :      }
; 5679 : 
; 5680 :    /* Check for explicit circumflex */
; 5681 : 
; 5682 :    else if (op != OP_CIRC) return FALSE;

	cmp	ecx, 25					; 00000019H
	je	SHORT $LN8@is_startli
$LN43@is_startli:
	pop	edi
	pop	esi

; 5654 :      {
; 5655 :      if (!is_startline(scode, bracket_map, backref_map)) return FALSE;

	xor	eax, eax
	pop	ebp

; 5690 : }

	ret	0
$LN5@is_startli:

; 5676 :      {
; 5677 :      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;

	cmp	BYTE PTR [eax+1], 12			; 0000000cH
	jne	SHORT $LN43@is_startli
	test	ebp, edi
	jne	SHORT $LN43@is_startli

; 5678 :      }
; 5679 : 
; 5680 :    /* Check for explicit circumflex */
; 5681 : 
; 5682 :    else if (op != OP_CIRC) return FALSE;

	jmp	SHORT $LN8@is_startli
$LN9@is_startli:

; 5670 :      { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }

	push	edi
	push	ebp
$LN51@is_startli:
	push	eax
	call	_is_startline
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN43@is_startli
$LN8@is_startli:

; 5683 : 
; 5684 :    /* Move on to the next alternative */
; 5685 : 
; 5686 :    code += GET(code, 1);

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

; 5687 :    }
; 5688 : while (*code == OP_ALT);  /* Loop for each alternative */

	cmp	BYTE PTR [esi], 83			; 00000053H
	je	$LL19@is_startli
	pop	edi
	pop	esi

; 5689 : return TRUE;

	mov	eax, 1
	pop	ebp

; 5690 : }

	ret	0
$LN52@is_startli:
	DD	$LN32@is_startli
	DD	$LN34@is_startli
	DD	$LN26@is_startli
	DD	$LN32@is_startli
$LN49@is_startli:
	DB	0
	DB	0
	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
	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	2
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	0
	DB	0
	DB	0
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	3
	DB	2
	DB	2
	DB	2
_is_startline ENDP
; Function compile flags: /Ogtpy
_TEXT	ENDS
;	COMDAT _find_firstassertedchar
_TEXT	SEGMENT
_code$ = 8						; size = 4
_options$ = 12						; size = 4
_inassert$ = 16						; size = 4
_find_firstassertedchar PROC				; COMDAT

; 5716 : {

	push	ebx
	push	ebp
	push	esi
	push	edi

; 5717 : register int c = -1;

	mov	edi, DWORD PTR _options$[esp+12]
	or	ebp, -1
	npad	5
$LL18@find_first:

; 5718 : do {
; 5719 :    int d;
; 5720 :    const uschar *scode =
; 5721 :      first_significant_code(code + 1+LINK_SIZE, options, PCRE_CASELESS, TRUE);

	mov	eax, DWORD PTR _code$[esp+12]
	mov	ebx, 1
	add	eax, 3
	mov	esi, ebx
	call	_first_significant_code

; 5722 :    register int op = *scode;

	movzx	ecx, BYTE PTR [eax]

; 5723 : 
; 5724 :    switch(op)

	lea	edx, DWORD PTR [ecx-27]
	cmp	edx, 68					; 00000044H
	ja	SHORT $LN13@find_first
	movzx	edx, BYTE PTR $LN27@find_first[edx]
	jmp	DWORD PTR $LN29@find_first[edx*4]
$LN12@find_first:

; 5728 : 
; 5729 :      case OP_BRA:
; 5730 :      case OP_CBRA:
; 5731 :      case OP_ASSERT:
; 5732 :      case OP_ONCE:
; 5733 :      case OP_COND:
; 5734 :      if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)

	xor	edx, edx
	cmp	ecx, 87					; 00000057H
	sete	dl
	push	edx
	push	edi
	push	eax
	call	_find_firstassertedchar
	add	esp, 12					; 0000000cH
	test	eax, eax
	jl	SHORT $LN13@find_first

; 5735 :        return -1;
; 5736 :      if (c < 0) c = d; else if (c != d) return -1;

	test	ebp, ebp
	jge	SHORT $LN10@find_first
	mov	ebp, eax
	jmp	SHORT $LN1@find_first
$LN7@find_first:

; 5737 :      break;
; 5738 : 
; 5739 :      case OP_EXACT:       /* Fall through */
; 5740 :      scode += 2;

	add	eax, 2
$LN6@find_first:

; 5741 : 
; 5742 :      case OP_CHAR:
; 5743 :      case OP_CHARNC:
; 5744 :      case OP_PLUS:
; 5745 :      case OP_MINPLUS:
; 5746 :      case OP_POSPLUS:
; 5747 :      if (!inassert) return -1;

	cmp	DWORD PTR _inassert$[esp+12], 0
	je	SHORT $LN13@find_first

; 5748 :      if (c < 0)

	test	ebp, ebp
	jge	SHORT $LN4@find_first

; 5749 :        {
; 5750 :        c = scode[1];
; 5751 :        if ((*options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;

	test	BYTE PTR [edi], bl
	movzx	ebp, BYTE PTR [eax+1]
	je	SHORT $LN1@find_first
	or	ebp, 256				; 00000100H

; 5752 :        }
; 5753 :      else if (c != scode[1]) return -1;

	jmp	SHORT $LN1@find_first
$LN4@find_first:
	movzx	eax, BYTE PTR [eax+1]
$LN10@find_first:
	cmp	ebp, eax
	jne	SHORT $LN13@find_first
$LN1@find_first:

; 5754 :      break;
; 5755 :      }
; 5756 : 
; 5757 :    code += GET(code, 1);

	mov	eax, DWORD PTR _code$[esp+12]
	xor	ecx, ecx
	mov	ch, BYTE PTR [eax+1]
	mov	cl, BYTE PTR [eax+2]
	add	eax, ecx

; 5758 :    }
; 5759 : while (*code == OP_ALT);

	cmp	BYTE PTR [eax], 83			; 00000053H
	mov	DWORD PTR _code$[esp+12], eax
	je	$LL18@find_first
	pop	edi
	pop	esi

; 5760 : return c;

	mov	eax, ebp
	pop	ebp
	pop	ebx

; 5761 : }

	ret	0
$LN13@find_first:
	pop	edi
	pop	esi
	pop	ebp

; 5725 :      {
; 5726 :      default:
; 5727 :      return -1;

	or	eax, -1
	pop	ebx

; 5761 : }

	ret	0
	npad	1
$LN29@find_first:
	DD	$LN6@find_first
	DD	$LN7@find_first
	DD	$LN12@find_first
	DD	$LN13@find_first
$LN27@find_first:
	DB	0
	DB	0
	DB	3
	DB	3
	DB	3
	DB	0
	DB	0
	DB	3
	DB	3
	DB	3
	DB	3
	DB	1
	DB	3
	DB	0
	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	2
	DB	3
	DB	3
	DB	3
	DB	3
	DB	2
	DB	2
	DB	2
	DB	2
_find_firstassertedchar ENDP
_TEXT	ENDS
PUBLIC	??_C@_0N@KODNOAPN@BSR_UNICODE?$CJ?$AA@		; `string'
PUBLIC	??_C@_0N@GHENKKML@BSR_ANYCRLF?$CJ?$AA@		; `string'
PUBLIC	??_C@_08HAMJONNL@ANYCRLF?$CJ?$AA@		; `string'
PUBLIC	??_C@_04KONMMB@ANY?$CJ?$AA@			; `string'
PUBLIC	??_C@_05GELBDDCJ@CRLF?$CJ?$AA@			; `string'
PUBLIC	??_C@_03DPCIKJPP@LF?$CJ?$AA@			; `string'
PUBLIC	??_C@_03HMGELCAF@CR?$CJ?$AA@			; `string'
PUBLIC	_pcre_compile2
EXTRN	_pcre_free:DWORD
EXTRN	_pcre_malloc:DWORD
EXTRN	__pcre_default_tables:BYTE
EXTRN	__chkstk:PROC
;	COMDAT ??_C@_0N@KODNOAPN@BSR_UNICODE?$CJ?$AA@
CONST	SEGMENT
??_C@_0N@KODNOAPN@BSR_UNICODE?$CJ?$AA@ DB 'BSR_UNICODE)', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0N@GHENKKML@BSR_ANYCRLF?$CJ?$AA@
CONST	SEGMENT
??_C@_0N@GHENKKML@BSR_ANYCRLF?$CJ?$AA@ DB 'BSR_ANYCRLF)', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_08HAMJONNL@ANYCRLF?$CJ?$AA@
CONST	SEGMENT
??_C@_08HAMJONNL@ANYCRLF?$CJ?$AA@ DB 'ANYCRLF)', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_04KONMMB@ANY?$CJ?$AA@
CONST	SEGMENT
??_C@_04KONMMB@ANY?$CJ?$AA@ DB 'ANY)', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_05GELBDDCJ@CRLF?$CJ?$AA@
CONST	SEGMENT
??_C@_05GELBDDCJ@CRLF?$CJ?$AA@ DB 'CRLF)', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_03DPCIKJPP@LF?$CJ?$AA@
CONST	SEGMENT
??_C@_03DPCIKJPP@LF?$CJ?$AA@ DB 'LF)', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_03HMGELCAF@CR?$CJ?$AA@
CONST	SEGMENT
??_C@_03HMGELCAF@CR?$CJ?$AA@ DB 'CR)', 00H		; `string'
; Function compile flags: /Ogtpy
CONST	ENDS
;	COMDAT _pcre_compile2
_TEXT	SEGMENT
_errorcode$ = -4212					; size = 4
_ptr$ = -4208						; size = 4
_temp_options$7044 = -4204				; size = 4
_length$ = -4204					; size = 4
_code$ = -4200						; size = 4
_reqbyte$ = -4196					; size = 4
_firstbyte$ = -4192					; size = 4
_compile_block$ = -4188					; size = 92
_cworkspace$ = -4096					; size = 4096
_pattern$ = 8						; size = 4
_options$ = 12						; size = 4
_errorcodeptr$ = 16					; size = 4
_errorptr$ = 20						; size = 4
_erroroffset$ = 24					; size = 4
_tables$ = 28						; size = 4
_pcre_compile2 PROC					; COMDAT

; 5798 : {

	mov	eax, 4212				; 00001074H
	call	__chkstk

; 5799 : real_pcre *re;
; 5800 : int length = 1;  /* For final END opcode */
; 5801 : int firstbyte, reqbyte, newline;
; 5802 : int errorcode = 0;
; 5803 : int skipatstart = 0;
; 5804 : #ifdef SUPPORT_UTF8
; 5805 : BOOL utf8;
; 5806 : #endif
; 5807 : size_t size;
; 5808 : uschar *code;
; 5809 : const uschar *codestart;
; 5810 : const uschar *ptr;
; 5811 : compile_data compile_block;
; 5812 : compile_data *cd = &compile_block;
; 5813 : 
; 5814 : /* This space is used for "compiling" into during the first phase, when we are
; 5815 : computing the amount of memory that is needed. Compiled items are thrown away
; 5816 : as soon as possible, so that a fairly large buffer should be sufficient for
; 5817 : this purpose. The same space is used in the second phase for remembering where
; 5818 : to fill in forward references to subpatterns. */
; 5819 : 
; 5820 : uschar cworkspace[COMPILE_WORK_SIZE];
; 5821 : 
; 5822 : /* Set this early so that early errors get offset 0. */
; 5823 : 
; 5824 : ptr = (const uschar *)pattern;
; 5825 : 
; 5826 : /* We can't pass back an error message if errorptr is NULL; I guess the best we
; 5827 : can do is just return NULL, but we can set a code value if there is a code
; 5828 : pointer. */
; 5829 : 
; 5830 : if (errorptr == NULL)

	mov	eax, DWORD PTR _errorptr$[esp+4208]
	push	ebx
	mov	ebx, DWORD PTR _pattern$[esp+4212]
	push	esi
	xor	esi, esi
	push	edi
	xor	edi, edi
	cmp	eax, esi
	mov	DWORD PTR _length$[esp+4224], 1
	mov	DWORD PTR _errorcode$[esp+4224], esi
	mov	DWORD PTR _ptr$[esp+4224], ebx
	jne	SHORT $LN67@pcre_compi

; 5831 :   {
; 5832 :   if (errorcodeptr != NULL) *errorcodeptr = 99;

	mov	eax, DWORD PTR _errorcodeptr$[esp+4220]
	cmp	eax, esi
	je	SHORT $LN66@pcre_compi
	mov	DWORD PTR [eax], 99			; 00000063H
$LN66@pcre_compi:
	pop	edi
	pop	esi

; 5833 :   return NULL;

	xor	eax, eax
	pop	ebx

; 6217 : }

	add	esp, 4212				; 00001074H
	ret	0
$LN67@pcre_compi:

; 5834 :   }
; 5835 : 
; 5836 : *errorptr = NULL;

	mov	DWORD PTR [eax], esi

; 5837 : if (errorcodeptr != NULL) *errorcodeptr = ERR0;

	mov	eax, DWORD PTR _errorcodeptr$[esp+4220]
	cmp	eax, esi
	je	SHORT $LN65@pcre_compi
	mov	DWORD PTR [eax], esi
$LN65@pcre_compi:

; 5838 : 
; 5839 : /* However, we can give a message for this error */
; 5840 : 
; 5841 : if (erroroffset == NULL)

	mov	eax, DWORD PTR _erroroffset$[esp+4220]
	cmp	eax, esi
	push	ebp
	jne	SHORT $LN64@pcre_compi

; 5842 :   {
; 5843 :   errorcode = ERR16;

	mov	eax, 16					; 00000010H

; 5844 :   goto PCRE_EARLY_ERROR_RETURN2;

	jmp	$PCRE_EARLY_ERROR_RETURN2$6938
$LN64@pcre_compi:

; 5845 :   }
; 5846 : 
; 5847 : *erroroffset = 0;
; 5848 : 
; 5849 : /* Can't support UTF8 unless PCRE has been compiled to include the code. */
; 5850 : 
; 5851 : #ifdef SUPPORT_UTF8
; 5852 : utf8 = (options & PCRE_UTF8) != 0;
; 5853 : if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
; 5854 :      (*erroroffset = _pcre_valid_utf8((uschar *)pattern, -1)) >= 0)
; 5855 :   {
; 5856 :   errorcode = ERR44;
; 5857 :   goto PCRE_EARLY_ERROR_RETURN2;
; 5858 :   }
; 5859 : #else
; 5860 : if ((options & PCRE_UTF8) != 0)

	mov	ebp, DWORD PTR _options$[esp+4224]
	test	ebp, 2048				; 00000800H
	mov	DWORD PTR [eax], esi
	je	SHORT $LN63@pcre_compi

; 5861 :   {
; 5862 :   errorcode = ERR32;

	mov	eax, 32					; 00000020H

; 5863 :   goto PCRE_EARLY_ERROR_RETURN;

	jmp	$PCRE_EARLY_ERROR_RETURN$6940
$LN63@pcre_compi:

; 5864 :   }
; 5865 : #endif
; 5866 : 
; 5867 : if ((options & ~PUBLIC_OPTIONS) != 0)

	test	ebp, -33323648				; fe038580H
	je	SHORT $LN62@pcre_compi

; 5868 :   {
; 5869 :   errorcode = ERR17;

	mov	eax, 17					; 00000011H

; 5870 :   goto PCRE_EARLY_ERROR_RETURN;

	jmp	$PCRE_EARLY_ERROR_RETURN$6940
$LN62@pcre_compi:

; 5871 :   }
; 5872 : 
; 5873 : /* Set up pointers to the individual character tables */
; 5874 : 
; 5875 : if (tables == NULL) tables = _pcre_default_tables;

	mov	eax, DWORD PTR _tables$[esp+4224]
	cmp	eax, esi
	jne	SHORT $LN61@pcre_compi
	mov	eax, OFFSET __pcre_default_tables
	mov	DWORD PTR _tables$[esp+4224], eax
$LN61@pcre_compi:

; 5876 : cd->lcc = tables + lcc_offset;

	mov	DWORD PTR _compile_block$[esp+4228], eax

; 5877 : cd->fcc = tables + fcc_offset;

	lea	ecx, DWORD PTR [eax+256]

; 5878 : cd->cbits = tables + cbits_offset;

	lea	edx, DWORD PTR [eax+512]

; 5879 : cd->ctypes = tables + ctypes_offset;

	add	eax, 832				; 00000340H
	mov	DWORD PTR _compile_block$[esp+4232], ecx
	mov	DWORD PTR _compile_block$[esp+4236], edx
	mov	DWORD PTR _compile_block$[esp+4240], eax

; 5880 : 
; 5881 : /* Check for global one-time settings at the start of the pattern, and remember
; 5882 : the offset for later. */
; 5883 : 
; 5884 : while (ptr[skipatstart] == '(' && ptr[skipatstart+1] == '*')

	cmp	BYTE PTR [ebx], 40			; 00000028H
	jne	$LN43@pcre_compi
	jmp	SHORT $LN60@pcre_compi
	npad	11
$LL101@pcre_compi:
	xor	esi, esi
$LN60@pcre_compi:
	cmp	BYTE PTR [ebx+edi+1], 42		; 0000002aH
	jne	$LN43@pcre_compi

; 5885 :   {
; 5886 :   int newnl = 0;
; 5887 :   int newbsr = 0;
; 5888 : 
; 5889 :   if (strncmp((char *)(ptr+skipatstart+2), "CR)", 3) == 0)

	push	3
	lea	esi, DWORD PTR [edi+ebx+2]
	push	OFFSET ??_C@_03HMGELCAF@CR?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN58@pcre_compi

; 5890 :     { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }

	add	edi, 5
	mov	eax, 1048576				; 00100000H

; 5906 :     options = (options & ~PCRE_NEWLINE_BITS) | newnl;

	and	ebp, -7340033				; ff8fffffH
	jmp	$LN104@pcre_compi
$LN58@pcre_compi:

; 5891 :   else if (strncmp((char *)(ptr+skipatstart+2), "LF)", 3)  == 0)

	push	3
	push	OFFSET ??_C@_03DPCIKJPP@LF?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN56@pcre_compi

; 5892 :     { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }

	add	edi, 5
	mov	eax, 2097152				; 00200000H

; 5906 :     options = (options & ~PCRE_NEWLINE_BITS) | newnl;

	and	ebp, -7340033				; ff8fffffH
	jmp	$LN104@pcre_compi
$LN56@pcre_compi:

; 5893 :   else if (strncmp((char *)(ptr+skipatstart+2), "CRLF)", 5)  == 0)

	push	5
	push	OFFSET ??_C@_05GELBDDCJ@CRLF?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN54@pcre_compi

; 5894 :     { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }

	add	edi, 7
	mov	eax, 3145728				; 00300000H

; 5906 :     options = (options & ~PCRE_NEWLINE_BITS) | newnl;

	and	ebp, -7340033				; ff8fffffH
	jmp	SHORT $LN104@pcre_compi
$LN54@pcre_compi:

; 5895 :   else if (strncmp((char *)(ptr+skipatstart+2), "ANY)", 4) == 0)

	push	4
	push	OFFSET ??_C@_04KONMMB@ANY?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN52@pcre_compi

; 5896 :     { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }

	add	edi, 6
	mov	eax, 4194304				; 00400000H

; 5906 :     options = (options & ~PCRE_NEWLINE_BITS) | newnl;

	and	ebp, -7340033				; ff8fffffH
	jmp	SHORT $LN104@pcre_compi
$LN52@pcre_compi:

; 5897 :   else if (strncmp((char *)(ptr+skipatstart+2), "ANYCRLF)", 8)  == 0)

	push	8
	push	OFFSET ??_C@_08HAMJONNL@ANYCRLF?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN50@pcre_compi

; 5898 :     { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }

	add	edi, 10					; 0000000aH
	mov	eax, 5242880				; 00500000H

; 5906 :     options = (options & ~PCRE_NEWLINE_BITS) | newnl;

	and	ebp, -7340033				; ff8fffffH
	jmp	SHORT $LN104@pcre_compi
$LN50@pcre_compi:

; 5899 : 
; 5900 :   else if (strncmp((char *)(ptr+skipatstart+2), "BSR_ANYCRLF)", 12) == 0)

	push	12					; 0000000cH
	push	OFFSET ??_C@_0N@GHENKKML@BSR_ANYCRLF?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN48@pcre_compi

; 5901 :     { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }

	add	edi, 14					; 0000000eH
	mov	eax, 8388608				; 00800000H
$LN90@pcre_compi:

; 5907 :   else if (newbsr != 0)
; 5908 :     options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;

	and	ebp, -25165825				; fe7fffffH
$LN104@pcre_compi:
	or	ebp, eax
	cmp	BYTE PTR [edi+ebx], 40			; 00000028H
	je	$LL101@pcre_compi
$LN102@pcre_compi:

; 5880 : 
; 5881 : /* Check for global one-time settings at the start of the pattern, and remember
; 5882 : the offset for later. */
; 5883 : 
; 5884 : while (ptr[skipatstart] == '(' && ptr[skipatstart+1] == '*')

	xor	esi, esi
$LN43@pcre_compi:

; 5909 :   else break;
; 5910 :   }
; 5911 : 
; 5912 : /* Check validity of \R options. */
; 5913 : 
; 5914 : switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))

	mov	eax, ebp
	and	eax, 25165824				; 01800000H
	je	SHORT $LN39@pcre_compi
	cmp	eax, 8388608				; 00800000H
	je	SHORT $LN39@pcre_compi
	cmp	eax, 16777216				; 01000000H
	je	SHORT $LN39@pcre_compi

; 5915 :   {
; 5916 :   case 0:
; 5917 :   case PCRE_BSR_ANYCRLF:
; 5918 :   case PCRE_BSR_UNICODE:
; 5919 :   break;
; 5920 :   default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;

	mov	eax, 56					; 00000038H
	jmp	$PCRE_EARLY_ERROR_RETURN$6940
$LN48@pcre_compi:

; 5902 :   else if (strncmp((char *)(ptr+skipatstart+2), "BSR_UNICODE)", 12) == 0)

	push	12					; 0000000cH
	push	OFFSET ??_C@_0N@KODNOAPN@BSR_UNICODE?$CJ?$AA@
	push	esi
	call	_strncmp
	add	esp, 12					; 0000000cH
	test	eax, eax
	jne	SHORT $LN102@pcre_compi

; 5903 :     { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }

	add	edi, 14					; 0000000eH
	mov	eax, 16777216				; 01000000H

; 5904 : 
; 5905 :   if (newnl != 0)

	jmp	SHORT $LN90@pcre_compi
$LN39@pcre_compi:

; 5921 :   }
; 5922 : 
; 5923 : /* Handle different types of newline. The three bits give seven cases. The
; 5924 : current code allows for fixed one- or two-byte sequences, plus "any" and
; 5925 : "anycrlf". */
; 5926 : 
; 5927 : switch (options & PCRE_NEWLINE_BITS)

	mov	eax, ebp
	and	eax, 7340032				; 00700000H
	cmp	eax, 3145728				; 00300000H
	mov	ecx, 2
	jg	SHORT $LN70@pcre_compi
	je	SHORT $LN32@pcre_compi
	cmp	eax, esi
	je	SHORT $LN35@pcre_compi
	cmp	eax, 1048576				; 00100000H
	je	SHORT $LN34@pcre_compi
	cmp	eax, 2097152				; 00200000H
	jne	SHORT $LN29@pcre_compi
$LN35@pcre_compi:

; 5931 :   case PCRE_NEWLINE_LF: newline = '\n'; break;

	mov	eax, 10					; 0000000aH
$LN26@pcre_compi:

; 5948 :   {
; 5949 :   cd->nltype = NLTYPE_FIXED;
; 5950 :   if (newline > 255)

	cmp	eax, 255				; 000000ffH
	mov	DWORD PTR _compile_block$[esp+4308], esi
	jle	SHORT $LN24@pcre_compi

; 5951 :     {
; 5952 :     cd->nllen = 2;

	mov	DWORD PTR _compile_block$[esp+4312], ecx

; 5953 :     cd->nl[0] = (newline >> 8) & 255;

	mov	ecx, eax
	sar	ecx, 8
	mov	BYTE PTR _compile_block$[esp+4316], cl

; 5954 :     cd->nl[1] = newline & 255;

	mov	BYTE PTR _compile_block$[esp+4317], al

; 5955 :     }
; 5956 :   else

	jmp	SHORT $LN23@pcre_compi
$LN34@pcre_compi:

; 5928 :   {
; 5929 :   case 0: newline = NEWLINE; break;   /* Build-time default */
; 5930 :   case PCRE_NEWLINE_CR: newline = '\r'; break;

	mov	eax, 13					; 0000000dH
	jmp	SHORT $LN26@pcre_compi
$LN32@pcre_compi:

; 5932 :   case PCRE_NEWLINE_CR+
; 5933 :        PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;

	mov	eax, 3338				; 00000d0aH
	jmp	SHORT $LN26@pcre_compi
$LN70@pcre_compi:

; 5921 :   }
; 5922 : 
; 5923 : /* Handle different types of newline. The three bits give seven cases. The
; 5924 : current code allows for fixed one- or two-byte sequences, plus "any" and
; 5925 : "anycrlf". */
; 5926 : 
; 5927 : switch (options & PCRE_NEWLINE_BITS)

	cmp	eax, 4194304				; 00400000H
	je	SHORT $LN92@pcre_compi
	cmp	eax, 5242880				; 00500000H
	je	SHORT $LN91@pcre_compi
$LN29@pcre_compi:

; 5934 :   case PCRE_NEWLINE_ANY: newline = -1; break;
; 5935 :   case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
; 5936 :   default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;

	mov	eax, 56					; 00000038H
	jmp	$PCRE_EARLY_ERROR_RETURN$6940
$LN91@pcre_compi:

; 5937 :   }
; 5938 : 
; 5939 : if (newline == -2)
; 5940 :   {
; 5941 :   cd->nltype = NLTYPE_ANYCRLF;

	mov	DWORD PTR _compile_block$[esp+4308], ecx
	jmp	SHORT $LN23@pcre_compi
$LN92@pcre_compi:

; 5942 :   }
; 5943 : else if (newline < 0)
; 5944 :   {
; 5945 :   cd->nltype = NLTYPE_ANY;

	mov	DWORD PTR _compile_block$[esp+4308], 1

; 5946 :   }
; 5947 : else

	jmp	SHORT $LN23@pcre_compi
$LN24@pcre_compi:

; 5957 :     {
; 5958 :     cd->nllen = 1;

	mov	DWORD PTR _compile_block$[esp+4312], 1

; 5959 :     cd->nl[0] = newline;

	mov	BYTE PTR _compile_block$[esp+4316], al
$LN23@pcre_compi:

; 5960 :     }
; 5961 :   }
; 5962 : 
; 5963 : /* Maximum back reference and backref bitmap. The bitmap records up to 31 back
; 5964 : references to help in deciding whether (.*) can be treated as anchored or not.
; 5965 : */
; 5966 : 
; 5967 : cd->top_backref = 0;
; 5968 : cd->backref_map = 0;
; 5969 : 
; 5970 : /* Reflect pattern for debugging output */
; 5971 : 
; 5972 : DPRINTF(("------------------------------------------------------------------\n"));
; 5973 : DPRINTF(("%s\n", pattern));
; 5974 : 
; 5975 : /* Pretend to compile the pattern while actually just accumulating the length
; 5976 : of memory required. This behaviour is triggered by passing a non-NULL final
; 5977 : argument to compile_regex(). We pass a block of workspace (cworkspace) for it
; 5978 : to compile parts of the pattern into; the compiled code is discarded when it is
; 5979 : no longer needed, so hopefully this workspace will never overflow, though there
; 5980 : is a test for its doing so. */
; 5981 : 
; 5982 : cd->bracount = cd->final_bracount = 0;
; 5983 : cd->names_found = 0;
; 5984 : cd->name_entry_size = 0;
; 5985 : cd->name_table = NULL;
; 5986 : cd->start_workspace = cworkspace;

	lea	edx, DWORD PTR _cworkspace$[esp+4228]

; 5987 : cd->start_code = cworkspace;

	mov	eax, edx
	mov	DWORD PTR _compile_block$[esp+4248], eax

; 5988 : cd->hwm = cworkspace;

	mov	ecx, edx

; 5989 : cd->start_pattern = (const uschar *)pattern;
; 5990 : cd->end_pattern = (const uschar *)(pattern + strlen(pattern));

	mov	eax, ebx
	mov	DWORD PTR _compile_block$[esp+4244], edx
	mov	DWORD PTR _compile_block$[esp+4284], esi
	mov	DWORD PTR _compile_block$[esp+4288], esi
	mov	DWORD PTR _compile_block$[esp+4280], esi
	mov	DWORD PTR _compile_block$[esp+4276], esi
	mov	DWORD PTR _compile_block$[esp+4268], esi
	mov	DWORD PTR _compile_block$[esp+4272], esi
	mov	DWORD PTR _compile_block$[esp+4264], esi
	mov	DWORD PTR _compile_block$[esp+4260], ecx
	mov	DWORD PTR _compile_block$[esp+4252], ebx
	lea	edx, DWORD PTR [eax+1]
	npad	5
$LL96@pcre_compi:
	mov	cl, BYTE PTR [eax]
	add	eax, 1
	test	cl, cl
	jne	SHORT $LL96@pcre_compi
	sub	eax, edx
	add	eax, ebx

; 5991 : cd->req_varyopt = 0;
; 5992 : cd->external_options = options;
; 5993 : cd->external_flags = 0;
; 5994 : 
; 5995 : /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
; 5996 : don't need to look at the result of the function here. The initial options have
; 5997 : been put into the cd block so that they can be changed if an option setting is
; 5998 : found within the regex right at the beginning. Bringing initial option settings
; 5999 : outside can help speed up starting point checks. */
; 6000 : 
; 6001 : ptr += skipatstart;
; 6002 : code = cworkspace;

	lea	edx, DWORD PTR _cworkspace$[esp+4228]
	mov	DWORD PTR _code$[esp+4228], edx
	mov	DWORD PTR _compile_block$[esp+4256], eax
	xor	eax, eax

; 6003 : *code = OP_BRA;
; 6004 : (void)compile_regex(cd->external_options, cd->external_options & PCRE_IMS,
; 6005 :   &code, &ptr, &errorcode, FALSE, FALSE, 0, &firstbyte, &reqbyte, NULL, cd,
; 6006 :   &length);

	lea	ecx, DWORD PTR _length$[esp+4228]
	push	ecx
	lea	edx, DWORD PTR _compile_block$[esp+4232]
	push	edx
	push	eax
	lea	ecx, DWORD PTR _reqbyte$[esp+4240]
	push	ecx
	lea	edx, DWORD PTR _firstbyte$[esp+4244]
	push	edx
	push	eax
	push	eax
	push	eax
	mov	DWORD PTR _compile_block$[esp+4332], eax
	mov	DWORD PTR _compile_block$[esp+4328], eax
	lea	eax, DWORD PTR _errorcode$[esp+4260]
	push	eax
	lea	ecx, DWORD PTR _ptr$[esp+4264]
	push	ecx
	lea	edx, DWORD PTR _code$[esp+4268]
	push	edx
	mov	eax, ebp
	and	eax, 7
	push	eax
	lea	esi, DWORD PTR [edi+ebx]
	push	ebp
	mov	DWORD PTR _compile_block$[esp+4344], ebp
	mov	DWORD PTR _ptr$[esp+4280], esi
	mov	BYTE PTR _cworkspace$[esp+4280], 93	; 0000005dH
	call	_compile_regex

; 6007 : if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;

	mov	eax, DWORD PTR _errorcode$[esp+4280]
	add	esp, 52					; 00000034H
	test	eax, eax
	jne	$PCRE_EARLY_ERROR_RETURN$6940

; 6008 : 
; 6009 : DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
; 6010 :   cd->hwm - cworkspace));
; 6011 : 
; 6012 : if (length > MAX_PATTERN_SIZE)

	mov	ebp, DWORD PTR _length$[esp+4228]
	cmp	ebp, 65536				; 00010000H
	jle	SHORT $LN21@pcre_compi

; 6013 :   {
; 6014 :   errorcode = ERR20;

	mov	eax, 20					; 00000014H

; 6015 :   goto PCRE_EARLY_ERROR_RETURN;

	jmp	$PCRE_EARLY_ERROR_RETURN$6940
$LN21@pcre_compi:

; 6016 :   }
; 6017 : 
; 6018 : /* Compute the size of data block needed and get it, either from malloc or
; 6019 : externally provided function. Integer overflow should no longer be possible
; 6020 : because nowadays we limit the maximum value of cd->names_found and
; 6021 : cd->name_entry_size. */
; 6022 : 
; 6023 : size = length + sizeof(real_pcre) + cd->names_found * (cd->name_entry_size + 3);

	mov	ecx, DWORD PTR _compile_block$[esp+4272]
	add	ecx, 3
	imul	ecx, DWORD PTR _compile_block$[esp+4268]
	lea	ebx, DWORD PTR [ecx+ebp+40]

; 6024 : re = (real_pcre *)(pcre_malloc)(size);

	push	ebx
	call	DWORD PTR _pcre_malloc
	mov	edi, eax
	add	esp, 4

; 6025 : 
; 6026 : if (re == NULL)

	test	edi, edi
	jne	SHORT $LN20@pcre_compi

; 6027 :   {
; 6028 :   errorcode = ERR21;

	lea	eax, DWORD PTR [edi+21]

; 6029 :   goto PCRE_EARLY_ERROR_RETURN;

	jmp	$LN105@pcre_compi
$LN20@pcre_compi:

; 6030 :   }
; 6031 : 
; 6032 : /* Put in the magic number, and save the sizes, initial options, internal
; 6033 : flags, and character table pointer. NULL is used for the default character
; 6034 : tables. The nullpad field is at the end; it's there to help in the case when a
; 6035 : regex compiled on a system with 4-byte pointers is run on another with 8-byte
; 6036 : pointers. */
; 6037 : 
; 6038 : re->magic_number = MAGIC_NUMBER;
; 6039 : re->size = size;

	mov	DWORD PTR [edi+4], ebx
	mov	DWORD PTR [edi], 1346589253		; 50435245H

; 6040 : re->options = cd->external_options;

	mov	edx, DWORD PTR _compile_block$[esp+4292]
	mov	DWORD PTR [edi+8], edx

; 6041 : re->flags = cd->external_flags;

	movzx	eax, WORD PTR _compile_block$[esp+4296]

; 6042 : re->dummy1 = 0;

	xor	ecx, ecx
	mov	WORD PTR [edi+12], ax
	mov	WORD PTR [edi+14], cx

; 6043 : re->first_byte = 0;

	mov	WORD PTR [edi+20], cx

; 6044 : re->req_byte = 0;

	mov	WORD PTR [edi+22], cx

; 6045 : re->name_table_offset = sizeof(real_pcre);

	mov	WORD PTR [edi+24], 40			; 00000028H

; 6046 : re->name_entry_size = cd->name_entry_size;

	movzx	edx, WORD PTR _compile_block$[esp+4272]
	mov	WORD PTR [edi+26], dx

; 6047 : re->name_count = cd->names_found;

	movzx	eax, WORD PTR _compile_block$[esp+4268]
	mov	WORD PTR [edi+28], ax

; 6048 : re->ref_count = 0;
; 6049 : re->tables = (tables == _pcre_default_tables)? NULL : tables;

	mov	eax, DWORD PTR _tables$[esp+4224]
	mov	edx, eax
	sub	edx, OFFSET __pcre_default_tables
	neg	edx
	sbb	edx, edx
	and	edx, eax
	mov	DWORD PTR [edi+32], edx
	mov	WORD PTR [edi+30], cx

; 6050 : re->nullpad = NULL;

	mov	DWORD PTR [edi+36], ecx

; 6051 : 
; 6052 : /* The starting points of the name/number translation table and of the code are
; 6053 : passed around in the compile data block. The start/end pattern and initial
; 6054 : options are already set from the pre-compile phase, as is the name_entry_size
; 6055 : field. Reset the bracket count and the names_found field. Also reset the hwm
; 6056 : field; this time it's used for remembering forward references to subpatterns.
; 6057 : */
; 6058 : 
; 6059 : cd->final_bracount = cd->bracount;  /* Save for checking forward references */

	mov	eax, DWORD PTR _compile_block$[esp+4276]
	mov	DWORD PTR _compile_block$[esp+4280], eax

; 6060 : cd->bracount = 0;

	mov	DWORD PTR _compile_block$[esp+4276], ecx

; 6061 : cd->names_found = 0;

	mov	DWORD PTR _compile_block$[esp+4268], ecx

; 6062 : cd->name_table = (uschar *)re + re->name_table_offset;

	movzx	eax, WORD PTR [edi+24]

; 6063 : codestart = cd->name_table + re->name_entry_size * re->name_count;
; 6064 : cd->start_code = codestart;
; 6065 : cd->hwm = cworkspace;
; 6066 : cd->req_varyopt = 0;
; 6067 : cd->had_accept = FALSE;
; 6068 : 
; 6069 : /* Set up a starting, non-extracting bracket, then compile the expression. On
; 6070 : error, errorcode will be set non-zero, so we don't need to look at the result
; 6071 : of the function here. */
; 6072 : 
; 6073 : ptr = (const uschar *)pattern + skipatstart;
; 6074 : code = (uschar *)codestart;
; 6075 : *code = OP_BRA;
; 6076 : (void)compile_regex(re->options, re->options & PCRE_IMS, &code, &ptr,
; 6077 :   &errorcode, FALSE, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, NULL);

	push	ecx
	add	eax, edi
	mov	DWORD PTR _compile_block$[esp+4268], eax
	movzx	edx, WORD PTR [edi+26]
	movzx	ebx, WORD PTR [edi+28]
	imul	ebx, edx
	lea	edx, DWORD PTR _compile_block$[esp+4232]
	push	edx
	push	ecx
	lea	edx, DWORD PTR _reqbyte$[esp+4240]
	push	edx
	lea	edx, DWORD PTR _firstbyte$[esp+4244]
	push	edx
	push	ecx
	push	ecx
	push	ecx
	add	ebx, eax
	mov	DWORD PTR _compile_block$[esp+4332], ecx
	mov	DWORD PTR _compile_block$[esp+4336], ecx
	lea	eax, DWORD PTR _cworkspace$[esp+4260]
	mov	DWORD PTR _compile_block$[esp+4280], ebx
	mov	DWORD PTR _compile_block$[esp+4292], eax
	lea	ecx, DWORD PTR _errorcode$[esp+4260]
	push	ecx
	mov	BYTE PTR [ebx], 93			; 0000005dH
	mov	eax, DWORD PTR [edi+8]
	lea	edx, DWORD PTR _ptr$[esp+4264]
	push	edx
	lea	ecx, DWORD PTR _code$[esp+4268]
	mov	edx, eax
	push	ecx
	and	edx, 7
	push	edx
	push	eax
	mov	DWORD PTR _ptr$[esp+4280], esi
	mov	DWORD PTR _code$[esp+4280], ebx
	call	_compile_regex

; 6078 : re->top_bracket = cd->bracount;

	movzx	eax, WORD PTR _compile_block$[esp+4328]
	mov	WORD PTR [edi+16], ax

; 6079 : re->top_backref = cd->top_backref;

	mov	cx, WORD PTR _compile_block$[esp+4336]
	mov	WORD PTR [edi+18], cx

; 6080 : re->flags = cd->external_flags;

	movzx	edx, WORD PTR _compile_block$[esp+4348]
	add	esp, 52					; 00000034H
	mov	WORD PTR [edi+12], dx

; 6081 : 
; 6082 : if (cd->had_accept) reqbyte = -1;   /* Must disable after (*ACCEPT) */

	cmp	DWORD PTR _compile_block$[esp+4304], 0
	je	SHORT $LN97@pcre_compi
	mov	DWORD PTR _reqbyte$[esp+4228], -1
$LN97@pcre_compi:

; 6083 : 
; 6084 : /* If not reached end of pattern on success, there's an excess bracket. */
; 6085 : 
; 6086 : if (errorcode == 0 && *ptr != 0) errorcode = ERR22;

	cmp	DWORD PTR _errorcode$[esp+4228], 0
	jne	SHORT $LN18@pcre_compi
	mov	eax, DWORD PTR _ptr$[esp+4228]
	cmp	BYTE PTR [eax], 0
	je	SHORT $LN18@pcre_compi
	mov	DWORD PTR _errorcode$[esp+4228], 22	; 00000016H
$LN18@pcre_compi:

; 6087 : 
; 6088 : /* Fill in the terminating state and check for disastrous overflow, but
; 6089 : if debugging, leave the test till after things are printed out. */
; 6090 : 
; 6091 : *code++ = OP_END;

	mov	eax, DWORD PTR _code$[esp+4228]
	mov	BYTE PTR [eax], 0
	add	eax, 1

; 6092 : 
; 6093 : #ifndef DEBUG
; 6094 : if (code - codestart > length) errorcode = ERR23;

	sub	eax, ebx
	cmp	eax, ebp
	jle	SHORT $LN83@pcre_compi
	mov	DWORD PTR _errorcode$[esp+4228], 23	; 00000017H

; 6095 : #endif
; 6096 : 
; 6097 : /* Fill in any forward references that are required. */
; 6098 : 
; 6099 : while (errorcode == 0 && cd->hwm > cworkspace)

	jmp	SHORT $LN88@pcre_compi
$LN83@pcre_compi:
	cmp	DWORD PTR _errorcode$[esp+4228], 0
	jne	SHORT $LN88@pcre_compi
$LL16@pcre_compi:
	mov	eax, DWORD PTR _compile_block$[esp+4260]
	lea	ecx, DWORD PTR _cworkspace$[esp+4228]
	cmp	eax, ecx
	jbe	SHORT $LN95@pcre_compi

; 6100 :   {
; 6101 :   int offset, recno;
; 6102 :   const uschar *groupptr;
; 6103 :   cd->hwm -= LINK_SIZE;

	sub	eax, 2
	mov	DWORD PTR _compile_block$[esp+4260], eax

; 6104 :   offset = GET(cd->hwm, 0);

	movzx	edx, BYTE PTR [eax+1]
	mov	dh, BYTE PTR [eax]

; 6105 :   recno = GET(codestart, offset);
; 6106 :   groupptr = find_bracket(codestart, (re->options & PCRE_UTF8) != 0, recno);

	xor	eax, eax
	mov	ebp, edx
	mov	ah, BYTE PTR [ebx+ebp]
	mov	al, BYTE PTR [ebx+ebp+1]
	mov	esi, eax
	mov	eax, ebx
	call	_find_bracket

; 6107 :   if (groupptr == NULL) errorcode = ERR53;

	test	eax, eax
	je	SHORT $LN94@pcre_compi

; 6108 :     else PUT(((uschar *)codestart), offset, groupptr - codestart);

	mov	ecx, eax
	sub	ecx, ebx
	sar	ecx, 8
	sub	al, bl
	mov	BYTE PTR [ebx+ebp], cl
	mov	BYTE PTR [ebx+ebp+1], al
	cmp	DWORD PTR _errorcode$[esp+4228], 0
	je	SHORT $LL16@pcre_compi

; 6095 : #endif
; 6096 : 
; 6097 : /* Fill in any forward references that are required. */
; 6098 : 
; 6099 : while (errorcode == 0 && cd->hwm > cworkspace)

	jmp	SHORT $LN88@pcre_compi
$LN94@pcre_compi:

; 6107 :   if (groupptr == NULL) errorcode = ERR53;

	mov	DWORD PTR _errorcode$[esp+4228], 53	; 00000035H

; 6109 :   }
; 6110 : 
; 6111 : /* Give an error if there's back reference to a non-existent capturing
; 6112 : subpattern. */
; 6113 : 
; 6114 : if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;

	jmp	SHORT $LN88@pcre_compi
$LN95@pcre_compi:
	mov	dx, WORD PTR [edi+18]
	cmp	dx, WORD PTR [edi+16]
	jbe	SHORT $LN11@pcre_compi
	mov	DWORD PTR _errorcode$[esp+4228], 15	; 0000000fH
$LN88@pcre_compi:

; 6115 : 
; 6116 : /* Failed to compile, or error while post-processing */
; 6117 : 
; 6118 : if (errorcode != 0)
; 6119 :   {
; 6120 :   (pcre_free)(re);

	push	edi
	call	DWORD PTR _pcre_free
	mov	eax, DWORD PTR _errorcode$[esp+4232]
	add	esp, 4
$LN105@pcre_compi:
	mov	ebx, DWORD PTR _pattern$[esp+4224]
$PCRE_EARLY_ERROR_RETURN$6940:

; 6121 :   PCRE_EARLY_ERROR_RETURN:
; 6122 :   *erroroffset = ptr - (const uschar *)pattern;

	mov	ecx, DWORD PTR _ptr$[esp+4228]
	mov	edx, DWORD PTR _erroroffset$[esp+4224]
	sub	ecx, ebx
	mov	DWORD PTR [edx], ecx
$PCRE_EARLY_ERROR_RETURN2$6938:

; 6123 :   PCRE_EARLY_ERROR_RETURN2:
; 6124 :   *errorptr = find_error_text(errorcode);

	test	eax, eax
	mov	ecx, eax
	mov	esi, OFFSET _error_texts
	jle	SHORT $LN77@pcre_compi
$LL76@pcre_compi:
	mov	dl, BYTE PTR [esi]
	add	esi, 1
	test	dl, dl
	jne	SHORT $LL76@pcre_compi
	sub	ecx, 1
	test	ecx, ecx
	jg	SHORT $LL76@pcre_compi
$LN77@pcre_compi:
	mov	ecx, DWORD PTR _errorptr$[esp+4224]
	mov	DWORD PTR [ecx], esi

; 6125 :   if (errorcodeptr != NULL) *errorcodeptr = errorcode;

	mov	ecx, DWORD PTR _errorcodeptr$[esp+4224]
	test	ecx, ecx
	je	SHORT $LN10@pcre_compi
	mov	DWORD PTR [ecx], eax
$LN10@pcre_compi:
	pop	ebp
	pop	edi
	pop	esi

; 6126 :   return NULL;

	xor	eax, eax
	pop	ebx

; 6217 : }

	add	esp, 4212				; 00001074H
	ret	0
$LN11@pcre_compi:

; 6127 :   }
; 6128 : 
; 6129 : /* If the anchored option was not passed, set the flag if we can determine that
; 6130 : the pattern is anchored by virtue of ^ characters or \A or anything else (such
; 6131 : as starting with .* when DOTALL is set).
; 6132 : 
; 6133 : Otherwise, if we know what the first byte has to be, save it, because that
; 6134 : speeds up unanchored matches no end. If not, see if we can set the
; 6135 : PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
; 6136 : start with ^. and also when all branches start with .* for non-DOTALL matches.
; 6137 : */
; 6138 : 
; 6139 : if ((re->options & PCRE_ANCHORED) == 0)

	mov	eax, DWORD PTR [edi+8]
	test	al, 16					; 00000010H
	jne	$LN99@pcre_compi

; 6140 :   {
; 6141 :   int temp_options = re->options;   /* May get changed during these scans */
; 6142 :   if (is_anchored(codestart, &temp_options, 0, cd->backref_map))

	mov	edx, DWORD PTR _compile_block$[esp+4288]
	push	edx
	mov	DWORD PTR _temp_options$7044[esp+4232], eax
	push	0
	lea	eax, DWORD PTR _temp_options$7044[esp+4236]
	push	eax
	push	ebx
	call	_is_anchored
	add	esp, 16					; 00000010H
	test	eax, eax
	je	SHORT $LN8@pcre_compi

; 6143 :     re->options |= PCRE_ANCHORED;

	or	DWORD PTR [edi+8], 16			; 00000010H

; 6144 :   else

	jmp	SHORT $LN99@pcre_compi
$LN8@pcre_compi:

; 6145 :     {
; 6146 :     if (firstbyte < 0)

	mov	eax, DWORD PTR _firstbyte$[esp+4228]
	test	eax, eax
	jge	SHORT $LN87@pcre_compi

; 6147 :       firstbyte = find_firstassertedchar(codestart, &temp_options, FALSE);

	push	0
	lea	ecx, DWORD PTR _temp_options$7044[esp+4232]
	push	ecx
	push	ebx
	call	_find_firstassertedchar
	add	esp, 12					; 0000000cH

; 6148 :     if (firstbyte >= 0)   /* Remove caseless flag for non-caseable chars */

	test	eax, eax
	jl	SHORT $LN5@pcre_compi
$LN87@pcre_compi:

; 6149 :       {
; 6150 :       int ch = firstbyte & 255;

	mov	ecx, eax
	and	ecx, 255				; 000000ffH

; 6151 :       re->first_byte = ((firstbyte & REQ_CASELESS) != 0 &&
; 6152 :          cd->fcc[ch] == ch)? ch : firstbyte;

	test	eax, 256				; 00000100H
	je	SHORT $LN71@pcre_compi
	mov	edx, DWORD PTR _compile_block$[esp+4232]
	movzx	edx, BYTE PTR [edx+ecx]
	cmp	edx, ecx
	jne	SHORT $LN71@pcre_compi
	mov	eax, ecx
$LN71@pcre_compi:

; 6153 :       re->flags |= PCRE_FIRSTSET;

	or	WORD PTR [edi+12], 2
	mov	WORD PTR [edi+20], ax
	jmp	SHORT $LN99@pcre_compi
$LN5@pcre_compi:

; 6154 :       }
; 6155 :     else if (is_startline(codestart, 0, cd->backref_map))

	mov	eax, DWORD PTR _compile_block$[esp+4288]
	push	eax
	push	0
	push	ebx
	call	_is_startline
	add	esp, 12					; 0000000cH
	test	eax, eax
	je	SHORT $LN99@pcre_compi

; 6156 :       re->flags |= PCRE_STARTLINE;

	or	WORD PTR [edi+12], 8
$LN99@pcre_compi:

; 6157 :     }
; 6158 :   }
; 6159 : 
; 6160 : /* For an anchored pattern, we use the "required byte" only if it follows a
; 6161 : variable length item in the regex. Remove the caseless flag for non-caseable
; 6162 : bytes. */
; 6163 : 
; 6164 : if (reqbyte >= 0 &&
; 6165 :      ((re->options & PCRE_ANCHORED) == 0 || (reqbyte & REQ_VARY) != 0))

	mov	eax, DWORD PTR _reqbyte$[esp+4228]
	test	eax, eax
	jl	SHORT $LN2@pcre_compi
	test	BYTE PTR [edi+8], 16			; 00000010H
	je	SHORT $LN1@pcre_compi
	test	eax, 512				; 00000200H
	je	SHORT $LN2@pcre_compi
$LN1@pcre_compi:

; 6166 :   {
; 6167 :   int ch = reqbyte & 255;

	mov	ecx, eax
	and	ecx, 255				; 000000ffH

; 6168 :   re->req_byte = ((reqbyte & REQ_CASELESS) != 0 &&
; 6169 :     cd->fcc[ch] == ch)? (reqbyte & ~REQ_CASELESS) : reqbyte;

	test	eax, 256				; 00000100H
	je	SHORT $LN73@pcre_compi
	mov	edx, DWORD PTR _compile_block$[esp+4232]
	movzx	edx, BYTE PTR [edx+ecx]
	cmp	edx, ecx
	jne	SHORT $LN73@pcre_compi
	and	eax, -257				; fffffeffH
$LN73@pcre_compi:

; 6170 :   re->flags |= PCRE_REQCHSET;

	or	WORD PTR [edi+12], 4
	mov	WORD PTR [edi+22], ax
$LN2@pcre_compi:
	pop	ebp

; 6171 :   }
; 6172 : 
; 6173 : /* Print out the compiled data if debugging is enabled. This is never the
; 6174 : case when building a production library. */
; 6175 : 
; 6176 : #ifdef DEBUG
; 6177 : 
; 6178 : printf("Length = %d top_bracket = %d top_backref = %d\n",
; 6179 :   length, re->top_bracket, re->top_backref);
; 6180 : 
; 6181 : printf("Options=%08x\n", re->options);
; 6182 : 
; 6183 : if ((re->flags & PCRE_FIRSTSET) != 0)
; 6184 :   {
; 6185 :   int ch = re->first_byte & 255;
; 6186 :   const char *caseless = ((re->first_byte & REQ_CASELESS) == 0)?
; 6187 :     "" : " (caseless)";
; 6188 :   if (isprint(ch)) printf("First char = %c%s\n", ch, caseless);
; 6189 :     else printf("First char = \\x%02x%s\n", ch, caseless);
; 6190 :   }
; 6191 : 
; 6192 : if ((re->flags & PCRE_REQCHSET) != 0)
; 6193 :   {
; 6194 :   int ch = re->req_byte & 255;
; 6195 :   const char *caseless = ((re->req_byte & REQ_CASELESS) == 0)?
; 6196 :     "" : " (caseless)";
; 6197 :   if (isprint(ch)) printf("Req char = %c%s\n", ch, caseless);
; 6198 :     else printf("Req char = \\x%02x%s\n", ch, caseless);
; 6199 :   }
; 6200 : 
; 6201 : pcre_printint(re, stdout, TRUE);
; 6202 : 
; 6203 : /* This check is done here in the debugging case so that the code that
; 6204 : was compiled can be seen. */
; 6205 : 
; 6206 : if (code - codestart > length)
; 6207 :   {
; 6208 :   (pcre_free)(re);
; 6209 :   *errorptr = find_error_text(ERR23);
; 6210 :   *erroroffset = ptr - (uschar *)pattern;
; 6211 :   if (errorcodeptr != NULL) *errorcodeptr = ERR23;
; 6212 :   return NULL;
; 6213 :   }
; 6214 : #endif   /* DEBUG */
; 6215 : 
; 6216 : return (pcre *)re;

	mov	eax, edi
	pop	edi
	pop	esi
	pop	ebx

; 6217 : }

	add	esp, 4212				; 00001074H
	ret	0
_pcre_compile2 ENDP
_TEXT	ENDS
PUBLIC	_pcre_compile
; Function compile flags: /Ogtpy
;	COMDAT _pcre_compile
_TEXT	SEGMENT
_pattern$ = 8						; size = 4
_options$ = 12						; size = 4
_errorptr$ = 16						; size = 4
_erroroffset$ = 20					; size = 4
_tables$ = 24						; size = 4
_pcre_compile PROC					; COMDAT

; 5791 : return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);

	mov	eax, DWORD PTR _tables$[esp-4]
	mov	ecx, DWORD PTR _erroroffset$[esp-4]
	mov	edx, DWORD PTR _errorptr$[esp-4]
	push	eax
	mov	eax, DWORD PTR _options$[esp]
	push	ecx
	mov	ecx, DWORD PTR _pattern$[esp+4]
	push	edx
	push	0
	push	eax
	push	ecx
	call	_pcre_compile2
	add	esp, 24					; 00000018H

; 5792 : }

	ret	0
_pcre_compile ENDP
_TEXT	ENDS
END
