#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned char literal_escape(unsigned char, int);
int /*<<< orphan*/ reg_error(char *);
void ConvertSubstituteRE(const char *source, char *dest, int max) {
  register unsigned char *src;
  register unsigned char *dst;
  register unsigned char c;
  register unsigned char test;
  if (source == NULL || dest == NULL) {
    reg_error("NULL parm to `ConvertSubstituteRE\'");
    return;
  }
  src = (unsigned char *)source;
  dst = (unsigned char *)dest;
  while ((c = *src++) != '\0') {
    if (c == '\\') {
      if (*src == 'u' || *src == 'U' || *src == 'l' || *src == 'L') {
        *dst++ = '\\';
        c = *src++;
        *dst++ = c;
        if (c == '\0') {
          break;
        } else {
          c = *src++;
        }
      }
    }
    if (c == '&') {
      *dst++ = '&';
    } else if (c == '\\') {
      if (*src == '0') {
        *dst++ = '&';
        src++;
      } else if ('1' <= *src && *src <= '9') {
        *dst++ = '\\';
        *dst++ = *src++;
      } else if ((test = literal_escape(*src, 0)) != '\0') {
        *dst++ = '\\';
        *dst++ = *src++;
      } else if (*src == '\0') {
        *dst++ = '\\';
      } else {
        *dst++ = *src++;
      }
    } else {
      if (((char *)dst - (char *)dest) >= (max - 1)) {
        break;
      } else {
        if ((test = literal_escape(c, 1))) {
          *dst++ = '\\';
          if (test == '0') {
            test = c;
            *dst++ = '0';
            *dst++ = ('0' + (test / 64));
            test -= (test / 64) * 64;
            *dst++ = ('0' + (test / 8));
            test -= (test / 8) * 8;
            *dst++ = ('0' + test);
          } else {
            *dst++ = test;
          }
        } else {
          *dst++ = c;
        }
      }
    }
  }
  *dst = '\0';
}


x86 assembly (clang, -O0):
<ConvertSubstituteRE>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     1149 <ConvertSubstituteRE+0x29>
cmpq   $0x0,-0x10(%rbp)
jne    115a <ConvertSubstituteRE+0x3a>
lea    0xeb0(%rip),%rdi
call   1030 <reg_error@plt>
jmp    1506 <ConvertSubstituteRE+0x3e6>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x29(%rbp)
movzbl %al,%eax
cmp    $0x0,%eax
je     14ff <ConvertSubstituteRE+0x3df>
movzbl -0x29(%rbp),%eax
cmp    $0x5c,%eax
jne    1241 <ConvertSubstituteRE+0x121>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x75,%eax
je     11d7 <ConvertSubstituteRE+0xb7>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x55,%eax
je     11d7 <ConvertSubstituteRE+0xb7>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x6c,%eax
je     11d7 <ConvertSubstituteRE+0xb7>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x4c,%eax
jne    123c <ConvertSubstituteRE+0x11c>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x5c,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
movzbl -0x29(%rbp),%eax
cmp    $0x0,%eax
jne    1223 <ConvertSubstituteRE+0x103>
jmp    14ff <ConvertSubstituteRE+0x3df>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x29(%rbp)
jmp    123c <ConvertSubstituteRE+0x11c>
jmp    1241 <ConvertSubstituteRE+0x121>
movzbl -0x29(%rbp),%eax
cmp    $0x26,%eax
jne    1265 <ConvertSubstituteRE+0x145>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x26,(%rax)
jmp    14fa <ConvertSubstituteRE+0x3da>
movzbl -0x29(%rbp),%eax
cmp    $0x5c,%eax
jne    13b5 <ConvertSubstituteRE+0x295>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
jne    12a5 <ConvertSubstituteRE+0x185>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x26,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    13b0 <ConvertSubstituteRE+0x290>
mov    -0x20(%rbp),%rax
movzbl (%rax),%ecx
mov    $0x31,%eax
cmp    %ecx,%eax
jg     1302 <ConvertSubstituteRE+0x1e2>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x39,%eax
jg     1302 <ConvertSubstituteRE+0x1e2>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x5c,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    13ab <ConvertSubstituteRE+0x28b>
mov    -0x20(%rbp),%rax
xor    %esi,%esi
movzbl (%rax),%edi
call   1040 <literal_escape@plt>
mov    %al,-0x2a(%rbp)
movzbl %al,%eax
cmp    $0x0,%eax
je     1358 <ConvertSubstituteRE+0x238>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x5c,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    13a6 <ConvertSubstituteRE+0x286>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x0,%eax
jne    137f <ConvertSubstituteRE+0x25f>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x5c,(%rax)
jmp    13a1 <ConvertSubstituteRE+0x281>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    13a6 <ConvertSubstituteRE+0x286>
jmp    13ab <ConvertSubstituteRE+0x28b>
jmp    13b0 <ConvertSubstituteRE+0x290>
jmp    14f5 <ConvertSubstituteRE+0x3d5>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     13d7 <ConvertSubstituteRE+0x2b7>
jmp    14ff <ConvertSubstituteRE+0x3df>
mov    $0x1,%esi
movzbl -0x29(%rbp),%edi
call   1040 <literal_escape@plt>
mov    %al,-0x2a(%rbp)
cmp    $0x0,%al
je     14d7 <ConvertSubstituteRE+0x3b7>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x5c,(%rax)
movzbl -0x2a(%rbp),%eax
cmp    $0x30,%eax
jne    14be <ConvertSubstituteRE+0x39e>
mov    -0x29(%rbp),%al
mov    %al,-0x2a(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x30,(%rax)
movzbl -0x2a(%rbp),%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
movzbl -0x2a(%rbp),%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
shl    $0x6,%ecx
movzbl -0x2a(%rbp),%eax
sub    %ecx,%eax
mov    %al,-0x2a(%rbp)
movzbl -0x2a(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
movzbl -0x2a(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
shl    $0x3,%ecx
movzbl -0x2a(%rbp),%eax
sub    %ecx,%eax
mov    %al,-0x2a(%rbp)
movzbl -0x2a(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    14d2 <ConvertSubstituteRE+0x3b2>
mov    -0x2a(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    14eb <ConvertSubstituteRE+0x3cb>
mov    -0x29(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    14f0 <ConvertSubstituteRE+0x3d0>
jmp    14f5 <ConvertSubstituteRE+0x3d5>
jmp    14fa <ConvertSubstituteRE+0x3da>
jmp    116a <ConvertSubstituteRE+0x4a>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ConvertSubstituteRE>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %rdi,%rdi
je     12c5 <ConvertSubstituteRE+0x1a5>
mov    %rsi,%r14
test   %rsi,%rsi
je     12c5 <ConvertSubstituteRE+0x1a5>
add    $0xffffffff,%edx
movslq %edx,%r15
movabs $0x20100000201,%r12
mov    %r14,%rbp
jmp    1170 <ConvertSubstituteRE+0x50>
movb   $0x26,0x0(%rbp)
add    $0x1,%rbp
add    $0x1,%r13
mov    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rdi),%r13
movzbl (%rdi),%ebx
cmp    $0x5c,%bl
je     11a0 <ConvertSubstituteRE+0x80>
test   %bl,%bl
je     12df <ConvertSubstituteRE+0x1bf>
cmp    $0x5c,%bl
je     11de <ConvertSubstituteRE+0xbe>
cmp    $0x26,%bl
jne    1230 <ConvertSubstituteRE+0x110>
movb   $0x26,0x0(%rbp)
add    $0x1,%rbp
mov    %r13,%rdi
jmp    1170 <ConvertSubstituteRE+0x50>
nop
movzbl 0x0(%r13),%eax
lea    -0x4c(%rax),%ecx
cmp    $0x29,%cl
ja     11e3 <ConvertSubstituteRE+0xc3>
movzbl %cl,%ecx
bt     %rcx,%r12
jae    11e3 <ConvertSubstituteRE+0xc3>
movb   $0x5c,0x0(%rbp)
movzbl 0x0(%r13),%eax
mov    %al,0x1(%rbp)
add    $0x2,%rbp
test   %al,%al
je     12df <ConvertSubstituteRE+0x1bf>
movzbl 0x2(%rdi),%ebx
add    $0x3,%rdi
mov    %rdi,%r13
cmp    $0x5c,%bl
jne    1189 <ConvertSubstituteRE+0x69>
movzbl 0x0(%r13),%eax
cmp    $0x30,%al
je     1155 <ConvertSubstituteRE+0x35>
lea    -0x31(%rax),%ecx
cmp    $0x8,%cl
jbe    1205 <ConvertSubstituteRE+0xe5>
movzbl %al,%edi
xor    %esi,%esi
call   1040 <literal_escape@plt>
test   %al,%al
je     12a7 <ConvertSubstituteRE+0x187>
movb   $0x5c,0x0(%rbp)
movzbl 0x0(%r13),%eax
add    $0x1,%r13
mov    %al,0x1(%rbp)
add    $0x2,%rbp
mov    %r13,%rdi
jmp    1170 <ConvertSubstituteRE+0x50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rax
sub    %r14,%rax
cmp    %r15,%rax
jge    12df <ConvertSubstituteRE+0x1bf>
movzbl %bl,%edi
mov    $0x1,%esi
call   1040 <literal_escape@plt>
lea    0x1(%rbp),%rcx
test   %al,%al
je     128b <ConvertSubstituteRE+0x16b>
movb   $0x5c,0x0(%rbp)
cmp    $0x30,%al
jne    1299 <ConvertSubstituteRE+0x179>
movb   $0x30,0x1(%rbp)
mov    %ebx,%eax
shr    $0x6,%al
or     $0x30,%al
mov    %al,0x2(%rbp)
mov    %ebx,%eax
shr    $0x3,%al
and    $0x7,%al
or     $0x30,%al
mov    %al,0x3(%rbp)
and    $0x7,%bl
or     $0x30,%bl
mov    %bl,0x4(%rbp)
add    $0x5,%rbp
mov    %r13,%rdi
jmp    1170 <ConvertSubstituteRE+0x50>
mov    %bl,0x0(%rbp)
mov    %r13,%rdi
mov    %rcx,%rbp
jmp    1170 <ConvertSubstituteRE+0x50>
add    $0x2,%rbp
mov    %al,(%rcx)
mov    %r13,%rdi
jmp    1170 <ConvertSubstituteRE+0x50>
movzbl 0x0(%r13),%eax
test   %al,%al
je     12bc <ConvertSubstituteRE+0x19c>
add    $0x1,%r13
mov    %al,0x0(%rbp)
jmp    1196 <ConvertSubstituteRE+0x76>
movb   $0x5c,0x0(%rbp)
jmp    1196 <ConvertSubstituteRE+0x76>
lea    0xd34(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <reg_error@plt>
movb   $0x0,0x0(%rbp)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [35 x i8] c"NULL parm to `ConvertSubstituteRE'\00"
define void @ConvertSubstituteRE(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8
%10 = alloca i8
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%11 = load i8*, i8** %4
%12 = icmp eq i8* %11, null
br i1 %12, label %16, label %13
13: ; preds = %3
%14 = load i8*, i8** %5
%15 = icmp eq i8* %14, null
br i1 %15, label %16, label %18
16: ; preds = %13, %3
%17 = call i32 @reg_error(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0))
br label %217
18: ; preds = %13
%19 = load i8*, i8** %4
store i8* %19, i8** %7
%20 = load i8*, i8** %5
store i8* %20, i8** %8
br label %21
21: ; preds = %214, %18
%22 = load i8*, i8** %7
%23 = getelementptr inbounds i8, i8* %22, i32 1
store i8* %23, i8** %7
%24 = load i8, i8* %22
store i8 %24, i8* %9
%25 = zext i8 %24 to i32
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %215
27: ; preds = %21
%28 = load i8, i8* %9
%29 = zext i8 %28 to i32
%30 = icmp eq i32 %29, 92
br i1 %30, label %31, label %70
31: ; preds = %27
%32 = load i8*, i8** %7
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = icmp eq i32 %34, 117
br i1 %35, label %51, label %36
36: ; preds = %31
%37 = load i8*, i8** %7
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
%40 = icmp eq i32 %39, 85
br i1 %40, label %51, label %41
41: ; preds = %36
%42 = load i8*, i8** %7
%43 = load i8, i8* %42
%44 = zext i8 %43 to i32
%45 = icmp eq i32 %44, 108
br i1 %45, label %51, label %46
46: ; preds = %41
%47 = load i8*, i8** %7
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = icmp eq i32 %49, 76
br i1 %50, label %51, label %69
51: ; preds = %46, %41, %36, %31
%52 = load i8*, i8** %8
%53 = getelementptr inbounds i8, i8* %52, i32 1
store i8* %53, i8** %8
store i8 92, i8* %52
%54 = load i8*, i8** %7
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %7
%56 = load i8, i8* %54
store i8 %56, i8* %9
%57 = load i8, i8* %9
%58 = load i8*, i8** %8
%59 = getelementptr inbounds i8, i8* %58, i32 1
store i8* %59, i8** %8
store i8 %57, i8* %58
%60 = load i8, i8* %9
%61 = zext i8 %60 to i32
%62 = icmp eq i32 %61, 0
br i1 %62, label %63, label %64
63: ; preds = %51
br label %215
64: ; preds = %51
%65 = load i8*, i8** %7
%66 = getelementptr inbounds i8, i8* %65, i32 1
store i8* %66, i8** %7
%67 = load i8, i8* %65
store i8 %67, i8* %9
br label %68
68: ; preds = %64
br label %69
69: ; preds = %68, %46
br label %70
70: ; preds = %69, %27
%71 = load i8, i8* %9
%72 = zext i8 %71 to i32
%73 = icmp eq i32 %72, 38
br i1 %73, label %74, label %77
74: ; preds = %70
%75 = load i8*, i8** %8
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %8
store i8 38, i8* %75
br label %214
77: ; preds = %70
%78 = load i8, i8* %9
%79 = zext i8 %78 to i32
%80 = icmp eq i32 %79, 92
br i1 %80, label %81, label %141
81: ; preds = %77
%82 = load i8*, i8** %7
%83 = load i8, i8* %82
%84 = zext i8 %83 to i32
%85 = icmp eq i32 %84, 48
br i1 %85, label %86, label %91
86: ; preds = %81
%87 = load i8*, i8** %8
%88 = getelementptr inbounds i8, i8* %87, i32 1
store i8* %88, i8** %8
store i8 38, i8* %87
%89 = load i8*, i8** %7
%90 = getelementptr inbounds i8, i8* %89, i32 1
store i8* %90, i8** %7
br label %140
91: ; preds = %81
%92 = load i8*, i8** %7
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = icmp sle i32 49, %94
br i1 %95, label %96, label %109
96: ; preds = %91
%97 = load i8*, i8** %7
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = icmp sle i32 %99, 57
br i1 %100, label %101, label %109
101: ; preds = %96
%102 = load i8*, i8** %8
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %8
store i8 92, i8* %102
%104 = load i8*, i8** %7
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %7
%106 = load i8, i8* %104
%107 = load i8*, i8** %8
%108 = getelementptr inbounds i8, i8* %107, i32 1
store i8* %108, i8** %8
store i8 %106, i8* %107
br label %139
109: ; preds = %96, %91
%110 = load i8*, i8** %7
%111 = load i8, i8* %110
%112 = call zeroext i8 @literal_escape(i8 zeroext %111, i32 0)
store i8 %112, i8* %10
%113 = zext i8 %112 to i32
%114 = icmp ne i32 %113, 0
br i1 %114, label %115, label %123
115: ; preds = %109
%116 = load i8*, i8** %8
%117 = getelementptr inbounds i8, i8* %116, i32 1
store i8* %117, i8** %8
store i8 92, i8* %116
%118 = load i8*, i8** %7
%119 = getelementptr inbounds i8, i8* %118, i32 1
store i8* %119, i8** %7
%120 = load i8, i8* %118
%121 = load i8*, i8** %8
%122 = getelementptr inbounds i8, i8* %121, i32 1
store i8* %122, i8** %8
store i8 %120, i8* %121
br label %138
123: ; preds = %109
%124 = load i8*, i8** %7
%125 = load i8, i8* %124
%126 = zext i8 %125 to i32
%127 = icmp eq i32 %126, 0
br i1 %127, label %128, label %131
128: ; preds = %123
%129 = load i8*, i8** %8
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %8
store i8 92, i8* %129
br label %137
131: ; preds = %123
%132 = load i8*, i8** %7
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %7
%134 = load i8, i8* %132
%135 = load i8*, i8** %8
%136 = getelementptr inbounds i8, i8* %135, i32 1
store i8* %136, i8** %8
store i8 %134, i8* %135
br label %137
137: ; preds = %131, %128
br label %138
138: ; preds = %137, %115
br label %139
139: ; preds = %138, %101
br label %140
140: ; preds = %139, %86
br label %213
141: ; preds = %77
%142 = load i8*, i8** %8
%143 = load i8*, i8** %5
%144 = ptrtoint i8* %142 to i64
%145 = ptrtoint i8* %143 to i64
%146 = sub i64 %144, %145
%147 = load i32, i32* %6
%148 = sub nsw i32 %147, 1
%149 = sext i32 %148 to i64
%150 = icmp sge i64 %146, %149
br i1 %150, label %151, label %152
151: ; preds = %141
br label %215
152: ; preds = %141
%153 = load i8, i8* %9
%154 = call zeroext i8 @literal_escape(i8 zeroext %153, i32 1)
store i8 %154, i8* %10
%155 = icmp ne i8 %154, 0
br i1 %155, label %156, label %207
156: ; preds = %152
%157 = load i8*, i8** %8
%158 = getelementptr inbounds i8, i8* %157, i32 1
store i8* %158, i8** %8
store i8 92, i8* %157
%159 = load i8, i8* %10
%160 = zext i8 %159 to i32
%161 = icmp eq i32 %160, 48
br i1 %161, label %162, label %202
162: ; preds = %156
%163 = load i8, i8* %9
store i8 %163, i8* %10
%164 = load i8*, i8** %8
%165 = getelementptr inbounds i8, i8* %164, i32 1
store i8* %165, i8** %8
store i8 48, i8* %164
%166 = load i8, i8* %10
%167 = zext i8 %166 to i32
%168 = sdiv i32 %167, 64
%169 = add nsw i32 48, %168
%170 = trunc i32 %169 to i8
%171 = load i8*, i8** %8
%172 = getelementptr inbounds i8, i8* %171, i32 1
store i8* %172, i8** %8
store i8 %170, i8* %171
%173 = load i8, i8* %10
%174 = zext i8 %173 to i32
%175 = sdiv i32 %174, 64
%176 = mul nsw i32 %175, 64
%177 = load i8, i8* %10
%178 = zext i8 %177 to i32
%179 = sub nsw i32 %178, %176
%180 = trunc i32 %179 to i8
store i8 %180, i8* %10
%181 = load i8, i8* %10
%182 = zext i8 %181 to i32
%183 = sdiv i32 %182, 8
%184 = add nsw i32 48, %183
%185 = trunc i32 %184 to i8
%186 = load i8*, i8** %8
%187 = getelementptr inbounds i8, i8* %186, i32 1
store i8* %187, i8** %8
store i8 %185, i8* %186
%188 = load i8, i8* %10
%189 = zext i8 %188 to i32
%190 = sdiv i32 %189, 8
%191 = mul nsw i32 %190, 8
%192 = load i8, i8* %10
%193 = zext i8 %192 to i32
%194 = sub nsw i32 %193, %191
%195 = trunc i32 %194 to i8
store i8 %195, i8* %10
%196 = load i8, i8* %10
%197 = zext i8 %196 to i32
%198 = add nsw i32 48, %197
%199 = trunc i32 %198 to i8
%200 = load i8*, i8** %8
%201 = getelementptr inbounds i8, i8* %200, i32 1
store i8* %201, i8** %8
store i8 %199, i8* %200
br label %206
202: ; preds = %156
%203 = load i8, i8* %10
%204 = load i8*, i8** %8
%205 = getelementptr inbounds i8, i8* %204, i32 1
store i8* %205, i8** %8
store i8 %203, i8* %204
br label %206
206: ; preds = %202, %162
br label %211
207: ; preds = %152
%208 = load i8, i8* %9
%209 = load i8*, i8** %8
%210 = getelementptr inbounds i8, i8* %209, i32 1
store i8* %210, i8** %8
store i8 %208, i8* %209
br label %211
211: ; preds = %207, %206
br label %212
212: ; preds = %211
br label %213
213: ; preds = %212, %140
br label %214
214: ; preds = %213, %74
br label %21
215: ; preds = %151, %63, %21
%216 = load i8*, i8** %8
store i8 0, i8* %216
br label %217
217: ; preds = %215, %16
ret void
}

LLVM IR (-O2):
@.str = [35 x i8] c"NULL parm to `ConvertSubstituteRE'\00"
define void @ConvertSubstituteRE(i8* %0, i8* %1, i32 %2) {
%4 = icmp eq i8* %0, null
%5 = icmp eq i8* %1, null
%6 = or i1 %4, %5
br i1 %6, label %11, label %7
7: ; preds = %3
%8 = ptrtoint i8* %1 to i64
%9 = add nsw i32 %2, -1
%10 = sext i32 %9 to i64
br label %13
11: ; preds = %3
%12 = tail call i32 @reg_error(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0))
br label %98
13: ; preds = %53, %7
%14 = phi i8* [ %0, %7 ], [ %54, %53 ]
%15 = phi i8* [ %1, %7 ], [ %55, %53 ]
%16 = getelementptr inbounds i8, i8* %14, i64 1
%17 = load i8, i8* %14
switch i8 %17, label %29 [
i8 0, label %96
i8 92, label %18
]
18: ; preds = %13
%19 = load i8, i8* %16
switch i8 %19, label %37 [
i8 117, label %20
i8 85, label %20
i8 108, label %20
i8 76, label %20
]
20: ; preds = %18, %18, %18, %18
%21 = getelementptr inbounds i8, i8* %15, i64 1
store i8 92, i8* %15
%22 = load i8, i8* %16
%23 = getelementptr inbounds i8, i8* %15, i64 2
store i8 %22, i8* %21
%24 = icmp eq i8 %22, 0
br i1 %24, label %96, label %25
25: ; preds = %20
%26 = getelementptr inbounds i8, i8* %14, i64 2
%27 = getelementptr inbounds i8, i8* %14, i64 3
%28 = load i8, i8* %26
br label %29
29: ; preds = %13, %25
%30 = phi i8* [ %27, %25 ], [ %16, %13 ]
%31 = phi i8* [ %23, %25 ], [ %15, %13 ]
%32 = phi i8 [ %28, %25 ], [ %17, %13 ]
switch i8 %32, label %72 [
i8 38, label %33
i8 92, label %35
]
33: ; preds = %29
%34 = getelementptr inbounds i8, i8* %31, i64 1
store i8 38, i8* %31
br label %53
35: ; preds = %29
%36 = load i8, i8* %30
br label %37
37: ; preds = %18, %35
%38 = phi i8 [ %36, %35 ], [ %19, %18 ]
%39 = phi i8* [ %31, %35 ], [ %15, %18 ]
%40 = phi i8* [ %30, %35 ], [ %16, %18 ]
%41 = icmp eq i8 %38, 48
br i1 %41, label %42, label %45
42: ; preds = %37
%43 = getelementptr inbounds i8, i8* %39, i64 1
store i8 38, i8* %39
%44 = getelementptr inbounds i8, i8* %40, i64 1
br label %53
45: ; preds = %37
%46 = add i8 %38, -49
%47 = icmp ult i8 %46, 9
br i1 %47, label %48, label %56
48: ; preds = %45
%49 = getelementptr inbounds i8, i8* %39, i64 1
store i8 92, i8* %39
%50 = getelementptr inbounds i8, i8* %40, i64 1
%51 = load i8, i8* %40
%52 = getelementptr inbounds i8, i8* %39, i64 2
store i8 %51, i8* %49
br label %53
53: ; preds = %48, %67, %69, %59, %42, %95, %94, %83, %33
%54 = phi i8* [ %30, %33 ], [ %44, %42 ], [ %50, %48 ], [ %61, %59 ], [ %40, %67 ], [ %70, %69 ], [ %30, %83 ], [ %30, %94 ], [ %30, %95 ]
%55 = phi i8* [ %34, %33 ], [ %43, %42 ], [ %52, %48 ], [ %63, %59 ], [ %68, %67 ], [ %71, %69 ], [ %93, %83 ], [ %82, %94 ], [ %79, %95 ]
br label %13
56: ; preds = %45
%57 = tail call zeroext i8 @literal_escape(i8 zeroext %38, i32 0)
%58 = icmp eq i8 %57, 0
br i1 %58, label %64, label %59
59: ; preds = %56
%60 = getelementptr inbounds i8, i8* %39, i64 1
store i8 92, i8* %39
%61 = getelementptr inbounds i8, i8* %40, i64 1
%62 = load i8, i8* %40
%63 = getelementptr inbounds i8, i8* %39, i64 2
store i8 %62, i8* %60
br label %53
64: ; preds = %56
%65 = load i8, i8* %40
%66 = icmp eq i8 %65, 0
br i1 %66, label %67, label %69
67: ; preds = %64
%68 = getelementptr inbounds i8, i8* %39, i64 1
store i8 92, i8* %39
br label %53
69: ; preds = %64
%70 = getelementptr inbounds i8, i8* %40, i64 1
%71 = getelementptr inbounds i8, i8* %39, i64 1
store i8 %65, i8* %39
br label %53
72: ; preds = %29
%73 = ptrtoint i8* %31 to i64
%74 = sub i64 %73, %8
%75 = icmp slt i64 %74, %10
br i1 %75, label %76, label %96
76: ; preds = %72
%77 = tail call zeroext i8 @literal_escape(i8 zeroext %32, i32 1)
%78 = icmp eq i8 %77, 0
%79 = getelementptr inbounds i8, i8* %31, i64 1
br i1 %78, label %95, label %80
80: ; preds = %76
store i8 92, i8* %31
%81 = icmp eq i8 %77, 48
%82 = getelementptr inbounds i8, i8* %31, i64 2
br i1 %81, label %83, label %94
83: ; preds = %80
store i8 48, i8* %79
%84 = lshr i8 %32, 6
%85 = or i8 %84, 48
%86 = getelementptr inbounds i8, i8* %31, i64 3
store i8 %85, i8* %82
%87 = lshr i8 %32, 3
%88 = and i8 %87, 7
%89 = or i8 %88, 48
%90 = getelementptr inbounds i8, i8* %31, i64 4
store i8 %89, i8* %86
%91 = and i8 %32, 7
%92 = or i8 %91, 48
%93 = getelementptr inbounds i8, i8* %31, i64 5
store i8 %92, i8* %90
br label %53
94: ; preds = %80
store i8 %77, i8* %79
br label %53
95: ; preds = %76
store i8 %32, i8* %31
br label %53
96: ; preds = %13, %72, %20
%97 = phi i8* [ %23, %20 ], [ %31, %72 ], [ %15, %13 ]
store i8 0, i8* %97
br label %98
98: ; preds = %96, %11
ret void
}