#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 int readEscapedSymbol(char **, char *, unsigned short *,
                               unsigned int *);
unsigned int utf8ToUnicode(char **, char *, unsigned int *);
unsigned int readRange(char **first, char *last, unsigned short *rangeLength,
                       unsigned int *range, unsigned short *inverseRangeLength,
                       unsigned int *inverseRange) {
  unsigned char parseBegin = 1;
  unsigned int lastSymbol = 0;
  unsigned int currentSymbol;
  unsigned char inverse = 0;
  unsigned int result;
  *rangeLength = 0;
  if (inverseRangeLength) {
    *inverseRangeLength = 0;
  }
  ++*first;
  if (*first[0] == '^') {
    if (*first == last) {
      return 501;
    }
    inverse = 1;
    ++*first;
  }
  if (*first[0] == ']') {
    if (*first == last) {
      return 501;
    }
    if (inverse) {
      inverseRange[*inverseRangeLength] = (unsigned int)']';
      ++*inverseRangeLength;
    } else {
      range[*rangeLength] = (unsigned int)']';
      ++*rangeLength;
    }
  }
  while (*first[0] != ']') {
    if (*first == last) {
      return 501;
    }
    if (!parseBegin) {
      if (!lastSymbol) {
        return 501;
      }
      result = utf8ToUnicode(first, last, &currentSymbol);
      if (result != 0) {
        return result;
      }
      while (currentSymbol != lastSymbol) {
        if (inverse) {
          inverseRange[*inverseRangeLength] = currentSymbol;
          ++*inverseRangeLength;
        } else {
          range[*rangeLength] = currentSymbol;
          ++*rangeLength;
        }
        if (currentSymbol > lastSymbol) {
          --currentSymbol;
        } else {
          ++currentSymbol;
        }
      }
      parseBegin = 1;
    } else {
      if (*first[0] == '-') {
        parseBegin = 0;
        ++*first;
      } else {
        if (*first[0] != '%') {
          result = utf8ToUnicode(first, last, &currentSymbol);
          if (result != 0) {
            return result;
          }
          if (inverse) {
            inverseRange[*inverseRangeLength] = currentSymbol;
            ++*inverseRangeLength;
          } else {
            range[*rangeLength] = currentSymbol;
            ++*rangeLength;
          }
          lastSymbol = currentSymbol;
        } else {
          if (inverse) {
            unsigned int result = readEscapedSymbol(
                first, last, inverseRangeLength, inverseRange);
            if (result != 0) {
              return result;
            }
          } else {
            unsigned int result =
                readEscapedSymbol(first, last, rangeLength, range);
            if (result != 0) {
              return result;
            }
          }
          lastSymbol = 0;
        }
      }
    }
  }
  if (!parseBegin) {
    if (inverse) {
      inverseRange[*inverseRangeLength] = (unsigned int)'-';
      ++*inverseRangeLength;
    } else {
      range[*rangeLength] = (unsigned int)'-';
      ++*rangeLength;
    }
  }
  ++*first;
  return 0;
}


x86 assembly (clang, -O0):
<readRange>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movb   $0x1,-0x39(%rbp)
movl   $0x0,-0x40(%rbp)
movb   $0x0,-0x45(%rbp)
mov    -0x20(%rbp),%rax
movw   $0x0,(%rax)
cmpq   $0x0,-0x30(%rbp)
je     116c <readRange+0x4c>
mov    -0x30(%rbp),%rax
movw   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
jne    11bc <readRange+0x9c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x18(%rbp),%rax
jne    11aa <readRange+0x8a>
movl   $0x1f5,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
movb   $0x1,-0x45(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x5d,%eax
jne    1240 <readRange+0x120>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x18(%rbp),%rax
jne    11ec <readRange+0xcc>
movl   $0x1f5,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
cmpb   $0x0,-0x45(%rbp)
je     121b <readRange+0xfb>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzwl (%rcx),%ecx
movl   $0x5d,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
jmp    123b <readRange+0x11b>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzwl (%rcx),%ecx
movl   $0x5d,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
jmp    1240 <readRange+0x120>
jmp    1245 <readRange+0x125>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x5d,%eax
je     148f <readRange+0x36f>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x18(%rbp),%rax
jne    1275 <readRange+0x155>
movl   $0x1f5,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
cmpb   $0x0,-0x39(%rbp)
jne    134d <readRange+0x22d>
cmpl   $0x0,-0x40(%rbp)
jne    1295 <readRange+0x175>
movl   $0x1f5,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x44(%rbp),%rdx
call   1040 <utf8ToUnicode@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     12be <readRange+0x19e>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
jmp    12c3 <readRange+0x1a3>
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     1344 <readRange+0x224>
cmpb   $0x0,-0x45(%rbp)
je     12fd <readRange+0x1dd>
mov    -0x44(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzwl (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
jmp    131c <readRange+0x1fc>
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzwl (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jbe    1336 <readRange+0x216>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    133f <readRange+0x21f>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12c3 <readRange+0x1a3>
movb   $0x1,-0x39(%rbp)
jmp    148a <readRange+0x36a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    1377 <readRange+0x257>
movb   $0x0,-0x39(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
jmp    1485 <readRange+0x365>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x25,%eax
je     140b <readRange+0x2eb>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x44(%rbp),%rdx
call   1040 <utf8ToUnicode@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     13b3 <readRange+0x293>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
cmpb   $0x0,-0x45(%rbp)
je     13e1 <readRange+0x2c1>
mov    -0x44(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzwl (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
jmp    1400 <readRange+0x2e0>
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzwl (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1480 <readRange+0x360>
cmpb   $0x0,-0x45(%rbp)
je     1447 <readRange+0x327>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
call   1030 <readEscapedSymbol@plt>
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     1442 <readRange+0x322>
mov    -0x50(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
jmp    1479 <readRange+0x359>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1030 <readEscapedSymbol@plt>
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
je     1474 <readRange+0x354>
mov    -0x54(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1502 <readRange+0x3e2>
jmp    1479 <readRange+0x359>
movl   $0x0,-0x40(%rbp)
jmp    1485 <readRange+0x365>
jmp    148a <readRange+0x36a>
jmp    1245 <readRange+0x125>
cmpb   $0x0,-0x39(%rbp)
jne    14ed <readRange+0x3cd>
cmpb   $0x0,-0x45(%rbp)
je     14c8 <readRange+0x3a8>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzwl (%rcx),%ecx
movl   $0x2d,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
jmp    14e8 <readRange+0x3c8>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzwl (%rcx),%ecx
movl   $0x2d,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%cx
add    $0x1,%cx
mov    %cx,(%rax)
jmp    14ed <readRange+0x3cd>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<readRange>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r15
mov    %rsi,%rbp
mov    %rdi,%r13
movw   $0x0,(%rdx)
test   %r8,%r8
je     1147 <readRange+0x27>
movw   $0x0,(%r8)
mov    0x0(%r13),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x0(%r13)
mov    0x1(%rax),%r12b
cmp    $0x5e,%r12b
jne    1173 <readRange+0x53>
cmp    %rbp,%rcx
je     11b4 <readRange+0x94>
lea    0x2(%rax),%rcx
mov    %rcx,0x0(%r13)
mov    0x2(%rax),%al
cmp    $0x5d,%al
je     117a <readRange+0x5a>
jmp    11a1 <readRange+0x81>
mov    %r12d,%eax
cmp    $0x5d,%al
jne    11a1 <readRange+0x81>
cmp    %rbp,%rcx
je     11b4 <readRange+0x94>
cmp    $0x5e,%r12b
mov    %rdx,%rax
cmove  %r8,%rax
mov    %r15,%rdi
cmove  %r9,%rdi
movzwl (%rax),%esi
movl   $0x5d,(%rdi,%rsi,4)
add    $0x1,%esi
mov    %si,(%rax)
mov    (%rcx),%bl
cmp    $0x5d,%bl
jne    11c8 <readRange+0xa8>
add    $0x1,%rcx
mov    %rcx,0x0(%r13)
xor    %eax,%eax
jmp    11b9 <readRange+0x99>
mov    $0x1f5,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x5e,%r12b
mov    %rdx,0x28(%rsp)
mov    %r8,0x10(%rsp)
cmove  %r8,%rdx
mov    %rdx,0x30(%rsp)
mov    %r15,0x20(%rsp)
mov    %r9,0x18(%rsp)
cmove  %r9,%r15
xor    %r14d,%r14d
mov    $0x1,%dl
jmp    121b <readRange+0xfb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
mov    %rcx,0x0(%r13)
mov    $0x1,%al
xor    %edx,%edx
mov    0x0(%r13),%rcx
mov    (%rcx),%bl
cmp    $0x5d,%bl
je     135b <readRange+0x23b>
mov    $0x1f5,%eax
cmp    %rbp,%rcx
je     11b9 <readRange+0x99>
test   %dl,%dl
je     1280 <readRange+0x160>
cmp    $0x25,%bl
je     1300 <readRange+0x1e0>
cmp    $0x2d,%bl
je     1200 <readRange+0xe0>
mov    %r13,%rdi
mov    %rbp,%rsi
lea    0xc(%rsp),%rdx
call   1040 <utf8ToUnicode@plt>
test   %eax,%eax
jne    11b9 <readRange+0x99>
mov    0xc(%rsp),%r14d
cmp    $0x5e,%r12b
jne    133b <readRange+0x21b>
mov    0x10(%rsp),%rdx
movzwl (%rdx),%eax
mov    0x18(%rsp),%rcx
mov    %r14d,(%rcx,%rax,4)
add    $0x1,%eax
mov    %ax,(%rdx)
jmp    1352 <readRange+0x232>
nopw   0x0(%rax,%rax,1)
test   %r14d,%r14d
je     11b9 <readRange+0x99>
mov    %r13,%rdi
mov    %rbp,%rsi
lea    0xc(%rsp),%rdx
call   1040 <utf8ToUnicode@plt>
test   %eax,%eax
jne    11b9 <readRange+0x99>
mov    0xc(%rsp),%eax
mov    $0x1,%dl
cmp    %r14d,%eax
je     12eb <readRange+0x1cb>
mov    0x30(%rsp),%rcx
movzwl (%rcx),%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzwl %cx,%esi
mov    %eax,(%r15,%rsi,4)
add    $0x1,%ecx
xor    %esi,%esi
cmp    %r14d,%eax
setbe  %sil
lea    (%rax,%rsi,2),%eax
add    $0xffffffff,%eax
cmp    %r14d,%eax
jne    12c0 <readRange+0x1a0>
mov    0x30(%rsp),%rax
mov    %cx,(%rax)
mov    %r14d,0xc(%rsp)
xor    %eax,%eax
jmp    120c <readRange+0xec>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%rdi
mov    %rbp,%rsi
cmp    $0x5e,%r12b
jne    1318 <readRange+0x1f8>
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rcx
jmp    1322 <readRange+0x202>
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rcx
call   1030 <readEscapedSymbol@plt>
test   %eax,%eax
jne    11b9 <readRange+0x99>
mov    $0x1,%dl
xor    %r14d,%r14d
xor    %eax,%eax
jmp    120c <readRange+0xec>
mov    0x28(%rsp),%rcx
movzwl (%rcx),%eax
mov    0x20(%rsp),%rdx
mov    %r14d,(%rdx,%rax,4)
add    $0x1,%eax
mov    %ax,(%rcx)
mov    $0x1,%dl
xor    %eax,%eax
jmp    120c <readRange+0xec>
test   %al,%al
je     11a8 <readRange+0x88>
cmp    $0x5e,%r12b
mov    0x28(%rsp),%rdx
cmove  0x10(%rsp),%rdx
mov    0x20(%rsp),%rsi
cmove  0x18(%rsp),%rsi
movzwl (%rdx),%eax
movl   $0x2d,(%rsi,%rax,4)
add    $0x1,%eax
mov    %ax,(%rdx)
jmp    11a8 <readRange+0x88>

LLVM IR (-O0):
define i32 @readRange(i8** %0, i8* %1, i16* %2, i32* %3, i16* %4, i32* %5) {
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i8*
%10 = alloca i16*
%11 = alloca i32*
%12 = alloca i16*
%13 = alloca i32*
%14 = alloca i8
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i8** %0, i8*** %8
store i8* %1, i8** %9
store i16* %2, i16** %10
store i32* %3, i32** %11
store i16* %4, i16** %12
store i32* %5, i32** %13
store i8 1, i8* %14
store i32 0, i32* %15
store i8 0, i8* %17
%21 = load i16*, i16** %10
store i16 0, i16* %21
%22 = load i16*, i16** %12
%23 = icmp ne i16* %22, null
br i1 %23, label %24, label %26
24: ; preds = %6
%25 = load i16*, i16** %12
store i16 0, i16* %25
br label %26
26: ; preds = %24, %6
%27 = load i8**, i8*** %8
%28 = load i8*, i8** %27
%29 = getelementptr inbounds i8, i8* %28, i32 1
store i8* %29, i8** %27
%30 = load i8**, i8*** %8
%31 = getelementptr inbounds i8*, i8** %30, i64 0
%32 = load i8*, i8** %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 94
br i1 %35, label %36, label %46
36: ; preds = %26
%37 = load i8**, i8*** %8
%38 = load i8*, i8** %37
%39 = load i8*, i8** %9
%40 = icmp eq i8* %38, %39
br i1 %40, label %41, label %42
41: ; preds = %36
store i32 501, i32* %7
br label %259
42: ; preds = %36
store i8 1, i8* %17
%43 = load i8**, i8*** %8
%44 = load i8*, i8** %43
%45 = getelementptr inbounds i8, i8* %44, i32 1
store i8* %45, i8** %43
br label %46
46: ; preds = %42, %26
%47 = load i8**, i8*** %8
%48 = getelementptr inbounds i8*, i8** %47, i64 0
%49 = load i8*, i8** %48
%50 = load i8, i8* %49
%51 = sext i8 %50 to i32
%52 = icmp eq i32 %51, 93
br i1 %52, label %53, label %81
53: ; preds = %46
%54 = load i8**, i8*** %8
%55 = load i8*, i8** %54
%56 = load i8*, i8** %9
%57 = icmp eq i8* %55, %56
br i1 %57, label %58, label %59
58: ; preds = %53
store i32 501, i32* %7
br label %259
59: ; preds = %53
%60 = load i8, i8* %17
%61 = icmp ne i8 %60, 0
br i1 %61, label %62, label %71
62: ; preds = %59
%63 = load i32*, i32** %13
%64 = load i16*, i16** %12
%65 = load i16, i16* %64
%66 = zext i16 %65 to i64
%67 = getelementptr inbounds i32, i32* %63, i64 %66
store i32 93, i32* %67
%68 = load i16*, i16** %12
%69 = load i16, i16* %68
%70 = add i16 %69, 1
store i16 %70, i16* %68
br label %80
71: ; preds = %59
%72 = load i32*, i32** %11
%73 = load i16*, i16** %10
%74 = load i16, i16* %73
%75 = zext i16 %74 to i64
%76 = getelementptr inbounds i32, i32* %72, i64 %75
store i32 93, i32* %76
%77 = load i16*, i16** %10
%78 = load i16, i16* %77
%79 = add i16 %78, 1
store i16 %79, i16* %77
br label %80
80: ; preds = %71, %62
br label %81
81: ; preds = %80, %46
br label %82
82: ; preds = %229, %81
%83 = load i8**, i8*** %8
%84 = getelementptr inbounds i8*, i8** %83, i64 0
%85 = load i8*, i8** %84
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = icmp ne i32 %87, 93
br i1 %88, label %89, label %230
89: ; preds = %82
%90 = load i8**, i8*** %8
%91 = load i8*, i8** %90
%92 = load i8*, i8** %9
%93 = icmp eq i8* %91, %92
br i1 %93, label %94, label %95
94: ; preds = %89
store i32 501, i32* %7
br label %259
95: ; preds = %89
%96 = load i8, i8* %14
%97 = icmp ne i8 %96, 0
br i1 %97, label %150, label %98
98: ; preds = %95
%99 = load i32, i32* %15
%100 = icmp ne i32 %99, 0
br i1 %100, label %102, label %101
101: ; preds = %98
store i32 501, i32* %7
br label %259
102: ; preds = %98
%103 = load i8**, i8*** %8
%104 = load i8*, i8** %9
%105 = call i32 @utf8ToUnicode(i8** %103, i8* %104, i32* %16)
store i32 %105, i32* %18
%106 = load i32, i32* %18
%107 = icmp ne i32 %106, 0
br i1 %107, label %108, label %110
108: ; preds = %102
%109 = load i32, i32* %18
store i32 %109, i32* %7
br label %259
110: ; preds = %102
br label %111
111: ; preds = %148, %110
%112 = load i32, i32* %16
%113 = load i32, i32* %15
%114 = icmp ne i32 %112, %113
br i1 %114, label %115, label %149
115: ; preds = %111
%116 = load i8, i8* %17
%117 = icmp ne i8 %116, 0
br i1 %117, label %118, label %128
118: ; preds = %115
%119 = load i32, i32* %16
%120 = load i32*, i32** %13
%121 = load i16*, i16** %12
%122 = load i16, i16* %121
%123 = zext i16 %122 to i64
%124 = getelementptr inbounds i32, i32* %120, i64 %123
store i32 %119, i32* %124
%125 = load i16*, i16** %12
%126 = load i16, i16* %125
%127 = add i16 %126, 1
store i16 %127, i16* %125
br label %138
128: ; preds = %115
%129 = load i32, i32* %16
%130 = load i32*, i32** %11
%131 = load i16*, i16** %10
%132 = load i16, i16* %131
%133 = zext i16 %132 to i64
%134 = getelementptr inbounds i32, i32* %130, i64 %133
store i32 %129, i32* %134
%135 = load i16*, i16** %10
%136 = load i16, i16* %135
%137 = add i16 %136, 1
store i16 %137, i16* %135
br label %138
138: ; preds = %128, %118
%139 = load i32, i32* %16
%140 = load i32, i32* %15
%141 = icmp ugt i32 %139, %140
br i1 %141, label %142, label %145
142: ; preds = %138
%143 = load i32, i32* %16
%144 = add i32 %143, -1
store i32 %144, i32* %16
br label %148
145: ; preds = %138
%146 = load i32, i32* %16
%147 = add i32 %146, 1
store i32 %147, i32* %16
br label %148
148: ; preds = %145, %142
br label %111
149: ; preds = %111
store i8 1, i8* %14
br label %229
150: ; preds = %95
%151 = load i8**, i8*** %8
%152 = getelementptr inbounds i8*, i8** %151, i64 0
%153 = load i8*, i8** %152
%154 = load i8, i8* %153
%155 = sext i8 %154 to i32
%156 = icmp eq i32 %155, 45
br i1 %156, label %157, label %161
157: ; preds = %150
store i8 0, i8* %14
%158 = load i8**, i8*** %8
%159 = load i8*, i8** %158
%160 = getelementptr inbounds i8, i8* %159, i32 1
store i8* %160, i8** %158
br label %228
161: ; preds = %150
%162 = load i8**, i8*** %8
%163 = getelementptr inbounds i8*, i8** %162, i64 0
%164 = load i8*, i8** %163
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = icmp ne i32 %166, 37
br i1 %167, label %168, label %201
168: ; preds = %161
%169 = load i8**, i8*** %8
%170 = load i8*, i8** %9
%171 = call i32 @utf8ToUnicode(i8** %169, i8* %170, i32* %16)
store i32 %171, i32* %18
%172 = load i32, i32* %18
%173 = icmp ne i32 %172, 0
br i1 %173, label %174, label %176
174: ; preds = %168
%175 = load i32, i32* %18
store i32 %175, i32* %7
br label %259
176: ; preds = %168
%177 = load i8, i8* %17
%178 = icmp ne i8 %177, 0
br i1 %178, label %179, label %189
179: ; preds = %176
%180 = load i32, i32* %16
%181 = load i32*, i32** %13
%182 = load i16*, i16** %12
%183 = load i16, i16* %182
%184 = zext i16 %183 to i64
%185 = getelementptr inbounds i32, i32* %181, i64 %184
store i32 %180, i32* %185
%186 = load i16*, i16** %12
%187 = load i16, i16* %186
%188 = add i16 %187, 1
store i16 %188, i16* %186
br label %199
189: ; preds = %176
%190 = load i32, i32* %16
%191 = load i32*, i32** %11
%192 = load i16*, i16** %10
%193 = load i16, i16* %192
%194 = zext i16 %193 to i64
%195 = getelementptr inbounds i32, i32* %191, i64 %194
store i32 %190, i32* %195
%196 = load i16*, i16** %10
%197 = load i16, i16* %196
%198 = add i16 %197, 1
store i16 %198, i16* %196
br label %199
199: ; preds = %189, %179
%200 = load i32, i32* %16
store i32 %200, i32* %15
br label %227
201: ; preds = %161
%202 = load i8, i8* %17
%203 = icmp ne i8 %202, 0
br i1 %203, label %204, label %215
204: ; preds = %201
%205 = load i8**, i8*** %8
%206 = load i8*, i8** %9
%207 = load i16*, i16** %12
%208 = load i32*, i32** %13
%209 = call i32 @readEscapedSymbol(i8** %205, i8* %206, i16* %207, i32* %208)
store i32 %209, i32* %19
%210 = load i32, i32* %19
%211 = icmp ne i32 %210, 0
br i1 %211, label %212, label %214
212: ; preds = %204
%213 = load i32, i32* %19
store i32 %213, i32* %7
br label %259
214: ; preds = %204
br label %226
215: ; preds = %201
%216 = load i8**, i8*** %8
%217 = load i8*, i8** %9
%218 = load i16*, i16** %10
%219 = load i32*, i32** %11
%220 = call i32 @readEscapedSymbol(i8** %216, i8* %217, i16* %218, i32* %219)
store i32 %220, i32* %20
%221 = load i32, i32* %20
%222 = icmp ne i32 %221, 0
br i1 %222, label %223, label %225
223: ; preds = %215
%224 = load i32, i32* %20
store i32 %224, i32* %7
br label %259
225: ; preds = %215
br label %226
226: ; preds = %225, %214
store i32 0, i32* %15
br label %227
227: ; preds = %226, %199
br label %228
228: ; preds = %227, %157
br label %229
229: ; preds = %228, %149
br label %82
230: ; preds = %82
%231 = load i8, i8* %14
%232 = icmp ne i8 %231, 0
br i1 %232, label %255, label %233
233: ; preds = %230
%234 = load i8, i8* %17
%235 = icmp ne i8 %234, 0
br i1 %235, label %236, label %245
236: ; preds = %233
%237 = load i32*, i32** %13
%238 = load i16*, i16** %12
%239 = load i16, i16* %238
%240 = zext i16 %239 to i64
%241 = getelementptr inbounds i32, i32* %237, i64 %240
store i32 45, i32* %241
%242 = load i16*, i16** %12
%243 = load i16, i16* %242
%244 = add i16 %243, 1
store i16 %244, i16* %242
br label %254
245: ; preds = %233
%246 = load i32*, i32** %11
%247 = load i16*, i16** %10
%248 = load i16, i16* %247
%249 = zext i16 %248 to i64
%250 = getelementptr inbounds i32, i32* %246, i64 %249
store i32 45, i32* %250
%251 = load i16*, i16** %10
%252 = load i16, i16* %251
%253 = add i16 %252, 1
store i16 %253, i16* %251
br label %254
254: ; preds = %245, %236
br label %255
255: ; preds = %254, %230
%256 = load i8**, i8*** %8
%257 = load i8*, i8** %256
%258 = getelementptr inbounds i8, i8* %257, i32 1
store i8* %258, i8** %256
store i32 0, i32* %7
br label %259
259: ; preds = %255, %223, %212, %174, %108, %101, %94, %58, %41
%260 = load i32, i32* %7
ret i32 %260
}

LLVM IR (-O2):
define i32 @readRange(i8** %0, i8* %1, i16* %2, i32* %3, i16* %4, i32* %5) {
%7 = alloca i32
%8 = bitcast i32* %7 to i8*
store i16 0, i16* %2
%9 = icmp eq i16* %4, null
br i1 %9, label %11, label %10
10: ; preds = %6
store i16 0, i16* %4
br label %11
11: ; preds = %10, %6
%12 = load i8*, i8** %0
%13 = getelementptr inbounds i8, i8* %12, i64 1
store i8* %13, i8** %0
%14 = load i8, i8* %13
%15 = icmp eq i8 %14, 94
br i1 %15, label %16, label %21
16: ; preds = %11
%17 = icmp eq i8* %13, %1
br i1 %17, label %112, label %18
18: ; preds = %16
%19 = getelementptr inbounds i8, i8* %12, i64 2
store i8* %19, i8** %0
%20 = load i8, i8* %19
br label %21
21: ; preds = %18, %11
%22 = phi i8 [ %20, %18 ], [ %14, %11 ]
%23 = phi i8* [ %19, %18 ], [ %13, %11 ]
%24 = icmp eq i8 %22, 93
br i1 %24, label %25, label %34
25: ; preds = %21
%26 = icmp eq i8* %23, %1
br i1 %26, label %112, label %27
27: ; preds = %25
%28 = select i1 %15, i16* %4, i16* %2
%29 = select i1 %15, i32* %5, i32* %3
%30 = load i16, i16* %28
%31 = zext i16 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
store i32 93, i32* %32
%33 = add i16 %30, 1
store i16 %33, i16* %28
br label %34
34: ; preds = %27, %21
%35 = load i8, i8* %23
%36 = icmp eq i8 %35, 93
br i1 %36, label %109, label %37
37: ; preds = %34
%38 = select i1 %15, i16* %4, i16* %2
%39 = select i1 %15, i32* %5, i32* %3
br label %40
40: ; preds = %37, %94
%41 = phi i8 [ %99, %94 ], [ %35, %37 ]
%42 = phi i8* [ %98, %94 ], [ %23, %37 ]
%43 = phi i8 [ %97, %94 ], [ 1, %37 ]
%44 = phi i32 [ %95, %94 ], [ 0, %37 ]
%45 = icmp eq i8* %42, %1
br i1 %45, label %112, label %46
46: ; preds = %40
%47 = icmp eq i8 %43, 0
br i1 %47, label %48, label %68
48: ; preds = %46
%49 = icmp eq i32 %44, 0
br i1 %49, label %112, label %50
50: ; preds = %48
%51 = call i32 @utf8ToUnicode(i8** %0, i8* %1, i32* %7)
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %112
53: ; preds = %50
%54 = load i32, i32* %7
%55 = icmp eq i32 %54, %44
br i1 %55, label %94, label %56
56: ; preds = %53
%57 = load i16, i16* %38
br label %58
58: ; preds = %56, %58
%59 = phi i16 [ %63, %58 ], [ %57, %56 ]
%60 = phi i32 [ %66, %58 ], [ %54, %56 ]
%61 = zext i16 %59 to i64
%62 = getelementptr inbounds i32, i32* %39, i64 %61
store i32 %60, i32* %62
%63 = add i16 %59, 1
%64 = icmp ugt i32 %60, %44
%65 = select i1 %64, i32 -1, i32 1
%66 = add i32 %65, %60
%67 = icmp eq i32 %66, %44
br i1 %67, label %93, label %58
68: ; preds = %46
switch i8 %41, label %71 [
i8 45, label %69
i8 37, label %86
]
69: ; preds = %68
%70 = getelementptr inbounds i8, i8* %42, i64 1
store i8* %70, i8** %0
br label %94
71: ; preds = %68
%72 = call i32 @utf8ToUnicode(i8** %0, i8* %1, i32* %7)
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %112
74: ; preds = %71
%75 = load i32, i32* %7
br i1 %15, label %76, label %81
76: ; preds = %74
%77 = load i16, i16* %4
%78 = zext i16 %77 to i64
%79 = getelementptr inbounds i32, i32* %5, i64 %78
store i32 %75, i32* %79
%80 = add i16 %77, 1
store i16 %80, i16* %4
br label %94
81: ; preds = %74
%82 = load i16, i16* %2
%83 = zext i16 %82 to i64
%84 = getelementptr inbounds i32, i32* %3, i64 %83
store i32 %75, i32* %84
%85 = add i16 %82, 1
store i16 %85, i16* %2
br label %94
86: ; preds = %68
br i1 %15, label %87, label %90
87: ; preds = %86
%88 = call i32 @readEscapedSymbol(i8** %0, i8* %1, i16* %4, i32* %5)
%89 = icmp eq i32 %88, 0
br i1 %89, label %94, label %112
90: ; preds = %86
%91 = call i32 @readEscapedSymbol(i8** %0, i8* %1, i16* %2, i32* %3)
%92 = icmp eq i32 %91, 0
br i1 %92, label %94, label %112
93: ; preds = %58
store i16 %63, i16* %38
store i32 %44, i32* %7
br label %94
94: ; preds = %76, %81, %53, %93, %87, %90, %69
%95 = phi i32 [ %44, %69 ], [ 0, %90 ], [ 0, %87 ], [ %44, %93 ], [ %44, %53 ], [ %75, %81 ], [ %75, %76 ]
%96 = phi i1 [ true, %69 ], [ false, %90 ], [ false, %87 ], [ false, %93 ], [ false, %53 ], [ false, %81 ], [ false, %76 ]
%97 = phi i8 [ 0, %69 ], [ 1, %90 ], [ 1, %87 ], [ 1, %93 ], [ 1, %53 ], [ 1, %81 ], [ 1, %76 ]
%98 = load i8*, i8** %0
%99 = load i8, i8* %98
%100 = icmp eq i8 %99, 93
br i1 %100, label %101, label %40
101: ; preds = %94
br i1 %96, label %102, label %109
102: ; preds = %101
%103 = select i1 %15, i16* %4, i16* %2
%104 = select i1 %15, i32* %5, i32* %3
%105 = load i16, i16* %103
%106 = zext i16 %105 to i64
%107 = getelementptr inbounds i32, i32* %104, i64 %106
store i32 45, i32* %107
%108 = add i16 %105, 1
store i16 %108, i16* %103
br label %109
109: ; preds = %102, %34, %101
%110 = phi i8* [ %98, %101 ], [ %23, %34 ], [ %98, %102 ]
%111 = getelementptr inbounds i8, i8* %110, i64 1
store i8* %111, i8** %0
br label %112
112: ; preds = %71, %50, %48, %40, %87, %90, %25, %16, %109
%113 = phi i32 [ 0, %109 ], [ 501, %16 ], [ 501, %25 ], [ %72, %71 ], [ %51, %50 ], [ 501, %48 ], [ 501, %40 ], [ %91, %90 ], [ %88, %87 ]
ret i32 %113
}