#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 */
struct inctrie {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ free(unsigned char *);
unsigned char *inctrie_lookup(struct inctrie *, char const *, int *);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char const *, int);
unsigned char *realloc(unsigned char *, int);
int strlen(char const *);
const unsigned char *inctrie_map(struct inctrie *ip, const char *s,
                                 const char *end, int append,
                                 void (*er)(const char *, const char *, void *,
                                            const char *, size_t),
                                 void *user, const char *f, size_t l) {
  static unsigned char *dest = NULL;
  static int dest_alloced = 0;
  int dest_used = (append ? strlen((const char *)dest) : 0);
  const char *s_orig = s;
  if (!s) {
    if (dest) {
      free(dest);
      dest_alloced = 0;
      dest = NULL;
    }
    return NULL;
  }
  if (!ip)
    return NULL;
  while (s < end && *s) {
    if (*(unsigned char *)s < 0x80) {
      int len;
      const unsigned char *ret = inctrie_lookup(ip, s, &len);
      if (ret) {
        int retlen = strlen((const char *)ret);
        if (dest_alloced <= (dest_used + retlen + 1)) {
          while (dest_alloced <= (dest_used + retlen + 1))
            dest_alloced += 128;
          dest = realloc(dest, dest_alloced * sizeof(unsigned char));
        }
        memcpy(dest + dest_used, ret, retlen);
        dest_used += retlen;
        s += len;
      } else {
        if (er)
          er(s_orig, s, user, f, l);
        if (dest_alloced <= (dest_used + 1)) {
          while (dest_alloced <= (dest_used + 2))
            dest_alloced += 128;
          dest = realloc(dest, dest_alloced * sizeof(unsigned char));
        }
        dest[dest_used++] = *s++;
      }
    } else {
      if (dest_alloced <= (dest_used + 1)) {
        while (dest_alloced <= (dest_used + 2))
          dest_alloced += 128;
        dest = realloc(dest, dest_alloced * sizeof(unsigned char));
      }
      dest[dest_used++] = *s++;
    }
  }
  if (dest)
    dest[dest_used] = '\0';
  return dest;
}


x86 assembly (clang, -O0):
<inctrie_map>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1195 <inctrie_map+0x45>
mov    0x2ec8(%rip),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x60(%rbp)
jmp    119f <inctrie_map+0x4f>
xor    %eax,%eax
mov    %eax,-0x60(%rbp)
jmp    119f <inctrie_map+0x4f>
mov    -0x60(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    11f4 <inctrie_map+0xa4>
cmpq   $0x0,0x2e90(%rip)
je     11e7 <inctrie_map+0x97>
mov    0x2e83(%rip),%rdi
call   1030 <free@plt>
movl   $0x0,0x2e7c(%rip)
movq   $0x0,0x2e69(%rip)
movq   $0x0,-0x8(%rbp)
jmp    1493 <inctrie_map+0x343>
cmpq   $0x0,-0x10(%rbp)
jne    120c <inctrie_map+0xbc>
movq   $0x0,-0x8(%rbp)
jmp    1493 <inctrie_map+0x343>
jmp    1211 <inctrie_map+0xc1>
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x61(%rbp)
jae    1234 <inctrie_map+0xe4>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    1244 <inctrie_map+0xf4>
jmp    146b <inctrie_map+0x31b>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x80,%eax
jge    13da <inctrie_map+0x28a>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x4c(%rbp),%rdx
call   1070 <inctrie_lookup@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
je     1324 <inctrie_map+0x1d4>
mov    -0x58(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x5c(%rbp)
mov    0x2dd0(%rip),%eax
mov    -0x3c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     12eb <inctrie_map+0x19b>
jmp    129e <inctrie_map+0x14e>
mov    0x2db4(%rip),%eax
mov    -0x3c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     12cb <inctrie_map+0x17b>
mov    0x2d9d(%rip),%eax
add    $0x80,%eax
mov    %eax,0x2d92(%rip)
jmp    129e <inctrie_map+0x14e>
mov    0x2d7e(%rip),%rdi
movslq 0x2d7f(%rip),%rax
shl    $0x0,%rax
mov    %eax,%esi
call   1060 <realloc@plt>
mov    %rax,0x2d65(%rip)
mov    0x2d5e(%rip),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x58(%rbp),%rsi
mov    -0x5c(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x5c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    13d5 <inctrie_map+0x285>
cmpq   $0x0,-0x30(%rbp)
je     1349 <inctrie_map+0x1f9>
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    0x18(%rbp),%r8
call   *%rax
mov    0x2d09(%rip),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     13ac <inctrie_map+0x25c>
jmp    1362 <inctrie_map+0x212>
mov    0x2cf0(%rip),%eax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jg     138c <inctrie_map+0x23c>
mov    0x2cdc(%rip),%eax
add    $0x80,%eax
mov    %eax,0x2cd1(%rip)
jmp    1362 <inctrie_map+0x212>
mov    0x2cbd(%rip),%rdi
movslq 0x2cbe(%rip),%rax
shl    $0x0,%rax
mov    %eax,%esi
call   1060 <realloc@plt>
mov    %rax,0x2ca4(%rip)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%dl
mov    0x2c8c(%rip),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1466 <inctrie_map+0x316>
mov    0x2c78(%rip),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     143d <inctrie_map+0x2ed>
jmp    13f3 <inctrie_map+0x2a3>
mov    0x2c5f(%rip),%eax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jg     141d <inctrie_map+0x2cd>
mov    0x2c4b(%rip),%eax
add    $0x80,%eax
mov    %eax,0x2c40(%rip)
jmp    13f3 <inctrie_map+0x2a3>
mov    0x2c2c(%rip),%rdi
movslq 0x2c2d(%rip),%rax
shl    $0x0,%rax
mov    %eax,%esi
call   1060 <realloc@plt>
mov    %rax,0x2c13(%rip)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%dl
mov    0x2bfb(%rip),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1211 <inctrie_map+0xc1>
cmpq   $0x0,0x2bdd(%rip)
je     1488 <inctrie_map+0x338>
mov    0x2bd0(%rip),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    0x2bc1(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inctrie_map>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r15
mov    %r8,%r12
mov    %rdx,%rbp
mov    %rsi,%rbx
mov    %rdi,0x8(%rsp)
test   %ecx,%ecx
je     1335 <inctrie_map+0x1e5>
mov    0x2ed2(%rip),%rdi
call   1040 <strlen@plt>
mov    %eax,%r14d
test   %rbx,%rbx
je     1341 <inctrie_map+0x1f1>
cmpq   $0x0,0x8(%rsp)
je     1381 <inctrie_map+0x231>
cmp    %rbp,%rbx
jae    1369 <inctrie_map+0x219>
mov    %r12,0x20(%rsp)
mov    %r15,0x18(%rsp)
mov    %rbx,0x10(%rsp)
mov    %rbx,%r12
jmp    1222 <inctrie_map+0xd2>
lea    0x80(%rax),%ecx
lea    (%r14,%rbp,1),%edx
add    $0x2,%edx
cmp    %ecx,%edx
cmovg  %edx,%ecx
mov    %eax,%edx
not    %edx
add    %ecx,%edx
and    $0xffffff80,%edx
lea    (%rax,%rdx,1),%esi
add    $0x80,%esi
mov    %esi,0x2e76(%rip)
mov    0x2e67(%rip),%rdi
call   1060 <realloc@plt>
mov    %rax,0x2e5b(%rip)
mov    %ebp,%r13d
add    %r14d,%r13d
movslq %r14d,%rdi
add    %rax,%rdi
mov    %r15,%rsi
mov    %ebp,%edx
call   1050 <memcpy@plt>
movslq 0x4(%rsp),%rax
add    %rax,%r12
mov    %rbx,%rbp
mov    %r13d,%r14d
cmp    %rbp,%r12
jae    136c <inctrie_map+0x21c>
movzbl (%r12),%ecx
test   %cl,%cl
je     1369 <inctrie_map+0x219>
js     1280 <inctrie_map+0x130>
mov    %rbp,%rbx
mov    0x8(%rsp),%rdi
mov    %r12,%rsi
lea    0x4(%rsp),%rdx
call   1070 <inctrie_lookup@plt>
test   %rax,%rax
je     12a0 <inctrie_map+0x150>
mov    %rax,%r15
mov    %rax,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
mov    0x2dfa(%rip),%eax
lea    (%r14,%rbp,1),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    11b8 <inctrie_map+0x68>
mov    0x2ddc(%rip),%rax
jmp    11f5 <inctrie_map+0xa5>
nopl   0x0(%rax)
mov    0x2dd2(%rip),%esi
lea    0x1(%r14),%r13d
cmp    %r13d,%esi
jle    12e0 <inctrie_map+0x190>
mov    0x2dba(%rip),%rax
jmp    1326 <inctrie_map+0x1d6>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
test   %rax,%rax
je     12c3 <inctrie_map+0x173>
mov    0x10(%rsp),%rdi
mov    %r12,%rsi
mov    0x18(%rsp),%rdx
mov    0x60(%rsp),%rcx
mov    0x68(%rsp),%r8
call   *%rax
mov    0x2d8f(%rip),%esi
lea    0x1(%r14),%r13d
cmp    %r13d,%esi
mov    %rbx,%rbp
jle    12e0 <inctrie_map+0x190>
mov    0x2d74(%rip),%rax
jmp    1321 <inctrie_map+0x1d1>
xchg   %ax,%ax
lea    0x2(%r14),%eax
cmp    %eax,%esi
jg     130e <inctrie_map+0x1be>
lea    0x80(%rsi),%eax
lea    0x3(%r14),%ecx
cmp    %ecx,%eax
cmovg  %eax,%ecx
mov    %esi,%eax
not    %eax
add    %ecx,%eax
and    $0xffffff80,%eax
add    %eax,%esi
add    $0x80,%esi
mov    %esi,0x2d4a(%rip)
mov    0x2d3b(%rip),%rdi
call   1060 <realloc@plt>
mov    %rax,0x2d2f(%rip)
movzbl (%r12),%ecx
add    $0x1,%r12
movslq %r14d,%rdx
mov    %cl,(%rax,%rdx,1)
jmp    1216 <inctrie_map+0xc6>
xor    %r14d,%r14d
test   %rbx,%rbx
jne    118f <inctrie_map+0x3f>
mov    0x2d08(%rip),%rdi
test   %rdi,%rdi
je     1381 <inctrie_map+0x231>
call   1030 <free@plt>
movl   $0x0,0x2cfc(%rip)
movq   $0x0,0x2ce9(%rip)
jmp    1381 <inctrie_map+0x231>
mov    %r14d,%r13d
mov    0x2cdd(%rip),%rax
test   %rax,%rax
je     1381 <inctrie_map+0x231>
movslq %r13d,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1383 <inctrie_map+0x233>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.inctrie = type { i32 }
@inctrie_map.dest = internal global i8* null
@inctrie_map.dest_alloced = internal global i32 0
define i8* @inctrie_map(%struct.inctrie* %0, i8* %1, i8* %2, i32 %3, void (i8*, i8*, i8*, i8*, i64)* %4, i8* %5, i8* %6, i64 %7) {
%9 = alloca i8*
%10 = alloca %struct.inctrie*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i32
%14 = alloca void (i8*, i8*, i8*, i8*, i64)*
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i64
%18 = alloca i32
%19 = alloca i8*
%20 = alloca i32
%21 = alloca i8*
%22 = alloca i32
store %struct.inctrie* %0, %struct.inctrie** %10
store i8* %1, i8** %11
store i8* %2, i8** %12
store i32 %3, i32* %13
store void (i8*, i8*, i8*, i8*, i64)* %4, void (i8*, i8*, i8*, i8*, i64)** %14
store i8* %5, i8** %15
store i8* %6, i8** %16
store i64 %7, i64* %17
%23 = load i32, i32* %13
%24 = icmp ne i32 %23, 0
br i1 %24, label %25, label %28
25: ; preds = %8
%26 = load i8*, i8** @inctrie_map.dest
%27 = call i32 @strlen(i8* %26)
br label %29
28: ; preds = %8
br label %29
29: ; preds = %28, %25
%30 = phi i32 [ %27, %25 ], [ 0, %28 ]
store i32 %30, i32* %18
%31 = load i8*, i8** %11
store i8* %31, i8** %19
%32 = load i8*, i8** %11
%33 = icmp ne i8* %32, null
br i1 %33, label %41, label %34
34: ; preds = %29
%35 = load i8*, i8** @inctrie_map.dest
%36 = icmp ne i8* %35, null
br i1 %36, label %37, label %40
37: ; preds = %34
%38 = load i8*, i8** @inctrie_map.dest
%39 = call i32 @free(i8* %38)
store i32 0, i32* @inctrie_map.dest_alloced
store i8* null, i8** @inctrie_map.dest
br label %40
40: ; preds = %37, %34
store i8* null, i8** %9
br label %192
41: ; preds = %29
%42 = load %struct.inctrie*, %struct.inctrie** %10
%43 = icmp ne %struct.inctrie* %42, null
br i1 %43, label %45, label %44
44: ; preds = %41
store i8* null, i8** %9
br label %192
45: ; preds = %41
br label %46
46: ; preds = %181, %45
%47 = load i8*, i8** %11
%48 = load i8*, i8** %12
%49 = icmp ult i8* %47, %48
br i1 %49, label %50, label %55
50: ; preds = %46
%51 = load i8*, i8** %11
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = icmp ne i32 %53, 0
br label %55
55: ; preds = %50, %46
%56 = phi i1 [ false, %46 ], [ %54, %50 ]
br i1 %56, label %57, label %182
57: ; preds = %55
%58 = load i8*, i8** %11
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = icmp slt i32 %60, 128
br i1 %61, label %62, label %151
62: ; preds = %57
%63 = load %struct.inctrie*, %struct.inctrie** %10
%64 = load i8*, i8** %11
%65 = call i8* @inctrie_lookup(%struct.inctrie* %63, i8* %64, i32* %20)
store i8* %65, i8** %21
%66 = load i8*, i8** %21
%67 = icmp ne i8* %66, null
br i1 %67, label %68, label %110
68: ; preds = %62
%69 = load i8*, i8** %21
%70 = call i32 @strlen(i8* %69)
store i32 %70, i32* %22
%71 = load i32, i32* @inctrie_map.dest_alloced
%72 = load i32, i32* %18
%73 = load i32, i32* %22
%74 = add nsw i32 %72, %73
%75 = add nsw i32 %74, 1
%76 = icmp sle i32 %71, %75
br i1 %76, label %77, label %95
77: ; preds = %68
br label %78
78: ; preds = %85, %77
%79 = load i32, i32* @inctrie_map.dest_alloced
%80 = load i32, i32* %18
%81 = load i32, i32* %22
%82 = add nsw i32 %80, %81
%83 = add nsw i32 %82, 1
%84 = icmp sle i32 %79, %83
br i1 %84, label %85, label %88
85: ; preds = %78
%86 = load i32, i32* @inctrie_map.dest_alloced
%87 = add nsw i32 %86, 128
store i32 %87, i32* @inctrie_map.dest_alloced
br label %78
88: ; preds = %78
%89 = load i8*, i8** @inctrie_map.dest
%90 = load i32, i32* @inctrie_map.dest_alloced
%91 = sext i32 %90 to i64
%92 = mul i64 %91, 1
%93 = trunc i64 %92 to i32
%94 = call i8* @realloc(i8* %89, i32 %93)
store i8* %94, i8** @inctrie_map.dest
br label %95
95: ; preds = %88, %68
%96 = load i8*, i8** @inctrie_map.dest
%97 = load i32, i32* %18
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %96, i64 %98
%100 = load i8*, i8** %21
%101 = load i32, i32* %22
%102 = call i32 @memcpy(i8* %99, i8* %100, i32 %101)
%103 = load i32, i32* %22
%104 = load i32, i32* %18
%105 = add nsw i32 %104, %103
store i32 %105, i32* %18
%106 = load i32, i32* %20
%107 = load i8*, i8** %11
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds i8, i8* %107, i64 %108
store i8* %109, i8** %11
br label %150
110: ; preds = %62
%111 = load void (i8*, i8*, i8*, i8*, i64)*, void (i8*, i8*, i8*, i8*, i64)** %14
%112 = icmp ne void (i8*, i8*, i8*, i8*, i64)* %111, null
br i1 %112, label %113, label %120
113: ; preds = %110
%114 = load void (i8*, i8*, i8*, i8*, i64)*, void (i8*, i8*, i8*, i8*, i64)** %14
%115 = load i8*, i8** %19
%116 = load i8*, i8** %11
%117 = load i8*, i8** %15
%118 = load i8*, i8** %16
%119 = load i64, i64* %17
br label %120
120: ; preds = %113, %110
%121 = load i32, i32* @inctrie_map.dest_alloced
%122 = load i32, i32* %18
%123 = add nsw i32 %122, 1
%124 = icmp sle i32 %121, %123
br i1 %124, label %125, label %141
125: ; preds = %120
br label %126
126: ; preds = %131, %125
%127 = load i32, i32* @inctrie_map.dest_alloced
%128 = load i32, i32* %18
%129 = add nsw i32 %128, 2
%130 = icmp sle i32 %127, %129
br i1 %130, label %131, label %134
131: ; preds = %126
%132 = load i32, i32* @inctrie_map.dest_alloced
%133 = add nsw i32 %132, 128
store i32 %133, i32* @inctrie_map.dest_alloced
br label %126
134: ; preds = %126
%135 = load i8*, i8** @inctrie_map.dest
%136 = load i32, i32* @inctrie_map.dest_alloced
%137 = sext i32 %136 to i64
%138 = mul i64 %137, 1
%139 = trunc i64 %138 to i32
%140 = call i8* @realloc(i8* %135, i32 %139)
store i8* %140, i8** @inctrie_map.dest
br label %141
141: ; preds = %134, %120
%142 = load i8*, i8** %11
%143 = getelementptr inbounds i8, i8* %142, i32 1
store i8* %143, i8** %11
%144 = load i8, i8* %142
%145 = load i8*, i8** @inctrie_map.dest
%146 = load i32, i32* %18
%147 = add nsw i32 %146, 1
store i32 %147, i32* %18
%148 = sext i32 %146 to i64
%149 = getelementptr inbounds i8, i8* %145, i64 %148
store i8 %144, i8* %149
br label %150
150: ; preds = %141, %95
br label %181
151: ; preds = %57
%152 = load i32, i32* @inctrie_map.dest_alloced
%153 = load i32, i32* %18
%154 = add nsw i32 %153, 1
%155 = icmp sle i32 %152, %154
br i1 %155, label %156, label %172
156: ; preds = %151
br label %157
157: ; preds = %162, %156
%158 = load i32, i32* @inctrie_map.dest_alloced
%159 = load i32, i32* %18
%160 = add nsw i32 %159, 2
%161 = icmp sle i32 %158, %160
br i1 %161, label %162, label %165
162: ; preds = %157
%163 = load i32, i32* @inctrie_map.dest_alloced
%164 = add nsw i32 %163, 128
store i32 %164, i32* @inctrie_map.dest_alloced
br label %157
165: ; preds = %157
%166 = load i8*, i8** @inctrie_map.dest
%167 = load i32, i32* @inctrie_map.dest_alloced
%168 = sext i32 %167 to i64
%169 = mul i64 %168, 1
%170 = trunc i64 %169 to i32
%171 = call i8* @realloc(i8* %166, i32 %170)
store i8* %171, i8** @inctrie_map.dest
br label %172
172: ; preds = %165, %151
%173 = load i8*, i8** %11
%174 = getelementptr inbounds i8, i8* %173, i32 1
store i8* %174, i8** %11
%175 = load i8, i8* %173
%176 = load i8*, i8** @inctrie_map.dest
%177 = load i32, i32* %18
%178 = add nsw i32 %177, 1
store i32 %178, i32* %18
%179 = sext i32 %177 to i64
%180 = getelementptr inbounds i8, i8* %176, i64 %179
store i8 %175, i8* %180
br label %181
181: ; preds = %172, %150
br label %46
182: ; preds = %55
%183 = load i8*, i8** @inctrie_map.dest
%184 = icmp ne i8* %183, null
br i1 %184, label %185, label %190
185: ; preds = %182
%186 = load i8*, i8** @inctrie_map.dest
%187 = load i32, i32* %18
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i8, i8* %186, i64 %188
store i8 0, i8* %189
br label %190
190: ; preds = %185, %182
%191 = load i8*, i8** @inctrie_map.dest
store i8* %191, i8** %9
br label %192
192: ; preds = %190, %44, %40
%193 = load i8*, i8** %9
ret i8* %193
}

LLVM IR (-O2):
%struct.inctrie = type { i32 }
@inctrie_map.dest = internal unnamed_addr global i8* null
@inctrie_map.dest_alloced = internal unnamed_addr global i32 0
define i8* @inctrie_map(%struct.inctrie* %0, i8* %1, i8* readnone %2, i32 %3, void (i8*, i8*, i8*, i8*, i64)* %4, i8* %5, i8* %6, i64 %7) {
%9 = alloca i32
%10 = icmp eq i32 %3, 0
br i1 %10, label %14, label %11
11: ; preds = %8
%12 = load i8*, i8** @inctrie_map.dest
%13 = tail call i32 @strlen(i8* %12)
br label %14
14: ; preds = %8, %11
%15 = phi i32 [ %13, %11 ], [ 0, %8 ]
%16 = icmp eq i8* %1, null
br i1 %16, label %17, label %22
17: ; preds = %14
%18 = load i8*, i8** @inctrie_map.dest
%19 = icmp eq i8* %18, null
br i1 %19, label %137, label %20
20: ; preds = %17
%21 = tail call i32 @free(i8* %18)
store i32 0, i32* @inctrie_map.dest_alloced
store i8* null, i8** @inctrie_map.dest
br label %137
22: ; preds = %14
%23 = icmp eq %struct.inctrie* %0, null
br i1 %23, label %137, label %24
24: ; preds = %22
%25 = icmp ult i8* %1, %2
br i1 %25, label %26, label %130
26: ; preds = %24
%27 = bitcast i32* %9 to i8*
%28 = icmp eq void (i8*, i8*, i8*, i8*, i64)* %4, null
br label %29
29: ; preds = %26, %126
%30 = phi i8* [ %1, %26 ], [ %128, %126 ]
%31 = phi i32 [ %15, %26 ], [ %127, %126 ]
%32 = load i8, i8* %30
%33 = icmp eq i8 %32, 0
br i1 %33, label %130, label %34
34: ; preds = %29
%35 = icmp sgt i8 %32, -1
br i1 %35, label %36, label %98
36: ; preds = %34
%37 = call i8* @inctrie_lookup(%struct.inctrie* %0, i8* %30, i32* %9)
%38 = icmp eq i8* %37, null
br i1 %38, label %66, label %39
39: ; preds = %36
%40 = call i32 @strlen(i8* %37)
%41 = load i32, i32* @inctrie_map.dest_alloced
%42 = add nsw i32 %40, %31
%43 = add nsw i32 %42, 1
%44 = icmp sgt i32 %41, %43
br i1 %44, label %45, label %47
45: ; preds = %39
%46 = load i8*, i8** @inctrie_map.dest
br label %58
47: ; preds = %39
%48 = add i32 %41, 128
%49 = add i32 %40, 2
%50 = add i32 %49, %31
%51 = call i32 @llvm.smax.i32(i32 %50, i32 %48)
%52 = xor i32 %41, -1
%53 = add i32 %51, %52
%54 = and i32 %53, -128
%55 = add i32 %48, %54
store i32 %55, i32* @inctrie_map.dest_alloced
%56 = load i8*, i8** @inctrie_map.dest
%57 = call i8* @realloc(i8* %56, i32 %55)
store i8* %57, i8** @inctrie_map.dest
br label %58
58: ; preds = %45, %47
%59 = phi i8* [ %46, %45 ], [ %57, %47 ]
%60 = sext i32 %31 to i64
%61 = getelementptr inbounds i8, i8* %59, i64 %60
%62 = call i32 @memcpy(i8* %61, i8* %37, i32 %40)
%63 = load i32, i32* %9
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %30, i64 %64
br label %95
66: ; preds = %36
br i1 %28, label %68, label %67
67: ; preds = %66
br label %68
68: ; preds = %67, %66
%69 = load i32, i32* @inctrie_map.dest_alloced
%70 = add nsw i32 %31, 1
%71 = icmp sgt i32 %69, %70
br i1 %71, label %72, label %74
72: ; preds = %68
%73 = load i8*, i8** @inctrie_map.dest
br label %89
74: ; preds = %68
%75 = add nsw i32 %31, 2
%76 = icmp sgt i32 %69, %75
br i1 %76, label %85, label %77
77: ; preds = %74
%78 = add i32 %69, 128
%79 = add i32 %31, 3
%80 = call i32 @llvm.smax.i32(i32 %78, i32 %79)
%81 = xor i32 %69, -1
%82 = add i32 %80, %81
%83 = and i32 %82, -128
%84 = add i32 %78, %83
store i32 %84, i32* @inctrie_map.dest_alloced
br label %85
85: ; preds = %77, %74
%86 = phi i32 [ %84, %77 ], [ %69, %74 ]
%87 = load i8*, i8** @inctrie_map.dest
%88 = call i8* @realloc(i8* %87, i32 %86)
store i8* %88, i8** @inctrie_map.dest
br label %89
89: ; preds = %72, %85
%90 = phi i8* [ %73, %72 ], [ %88, %85 ]
%91 = getelementptr inbounds i8, i8* %30, i64 1
%92 = load i8, i8* %30
%93 = sext i32 %31 to i64
%94 = getelementptr inbounds i8, i8* %90, i64 %93
store i8 %92, i8* %94
br label %95
95: ; preds = %89, %58
%96 = phi i32 [ %42, %58 ], [ %70, %89 ]
%97 = phi i8* [ %65, %58 ], [ %91, %89 ]
br label %126
98: ; preds = %34
%99 = load i32, i32* @inctrie_map.dest_alloced
%100 = add nsw i32 %31, 1
%101 = icmp sgt i32 %99, %100
br i1 %101, label %102, label %104
102: ; preds = %98
%103 = load i8*, i8** @inctrie_map.dest
br label %120
104: ; preds = %98
%105 = add nsw i32 %31, 2
%106 = icmp sgt i32 %99, %105
br i1 %106, label %115, label %107
107: ; preds = %104
%108 = add i32 %99, 128
%109 = add i32 %31, 3
%110 = call i32 @llvm.smax.i32(i32 %108, i32 %109)
%111 = xor i32 %99, -1
%112 = add i32 %110, %111
%113 = and i32 %112, -128
%114 = add i32 %108, %113
store i32 %114, i32* @inctrie_map.dest_alloced
br label %115
115: ; preds = %107, %104
%116 = phi i32 [ %114, %107 ], [ %99, %104 ]
%117 = load i8*, i8** @inctrie_map.dest
%118 = call i8* @realloc(i8* %117, i32 %116)
store i8* %118, i8** @inctrie_map.dest
%119 = load i8, i8* %30
br label %120
120: ; preds = %102, %115
%121 = phi i8* [ %118, %115 ], [ %103, %102 ]
%122 = phi i8 [ %119, %115 ], [ %32, %102 ]
%123 = getelementptr inbounds i8, i8* %30, i64 1
%124 = sext i32 %31 to i64
%125 = getelementptr inbounds i8, i8* %121, i64 %124
store i8 %122, i8* %125
br label %126
126: ; preds = %120, %95
%127 = phi i32 [ %96, %95 ], [ %100, %120 ]
%128 = phi i8* [ %97, %95 ], [ %123, %120 ]
%129 = icmp ult i8* %128, %2
br i1 %129, label %29, label %130
130: ; preds = %29, %126, %24
%131 = phi i32 [ %15, %24 ], [ %127, %126 ], [ %31, %29 ]
%132 = load i8*, i8** @inctrie_map.dest
%133 = icmp eq i8* %132, null
br i1 %133, label %137, label %134
134: ; preds = %130
%135 = sext i32 %131 to i64
%136 = getelementptr inbounds i8, i8* %132, i64 %135
store i8 0, i8* %136
br label %137
137: ; preds = %130, %134, %22, %17, %20
%138 = phi i8* [ null, %20 ], [ null, %17 ], [ null, %22 ], [ %132, %134 ], [ null, %130 ]
ret i8* %138
}