#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 */
int /*<<< orphan*/ assert(int);
int strlen(char const *);
int norm(char *dest, int len, const char *src) {
  const char *s = src;
  char *d = dest;
  char *stk[256];
  int top = 0;
  enum { L0, L1, L2, L3, L4 } state = L0;
  assert(strlen(src) <= len);
  while (*s) {
    char c = *s;
    enum { slash, dot, other } cls;
    switch (c) {
    case '/': {
      cls = slash;
      break;
    }
    case '.': {
      cls = dot;
      break;
    }
    default: {
      cls = other;
    }
    }
    switch (state) {
    case L0: {
      switch (cls) {
      case slash: {
        do {
          *d++ = *s++;
        } while (0);
        state = L1;
        break;
      }
      case dot:
      case other: {
        dest[0] = '\0';
        return -1;
      }
      }
      break;
    }
    case L1: {
      switch (cls) {
      case slash: {
        do {
          s++;
        } while (0);
        break;
      }
      case dot: {
        do {
          do {
            stk[top++] = d;
          } while (0);
        } while (0);
        do {
          *d++ = *s++;
        } while (0);
        state = L2;
        break;
      }
      case other: {
        do {
          do {
            stk[top++] = d;
          } while (0);
        } while (0);
        do {
          *d++ = *s++;
        } while (0);
        state = L4;
        break;
      }
      }
      break;
    }
    case L2: {
      switch (cls) {
      case slash: {
        do {
          do {
            if (top == 0) {
              dest[0] = '\0';
              return -1;
            }
            d = stk[--top];
          } while (0);
        } while (0);
        state = L1;
        break;
      }
      case dot: {
        do {
          *d++ = *s++;
        } while (0);
        state = L3;
        break;
      }
      case other: {
        do {
          *d++ = *s++;
        } while (0);
        state = L4;
        break;
      }
      }
      break;
    }
    case L3: {
      switch (cls) {
      case slash: {
        do {
          do {
            if (top == 0) {
              dest[0] = '\0';
              return -1;
            }
            d = stk[--top];
          } while (0);
          do {
            if (top == 0) {
              dest[0] = '\0';
              return -1;
            }
            d = stk[--top];
          } while (0);
        } while (0);
        state = L1;
        break;
      }
      case dot:
      case other: {
        do {
          *d++ = *s++;
        } while (0);
        state = L4;
        break;
      }
      }
      break;
    }
    case L4: {
      switch (cls) {
      case slash: {
        do {
          *d++ = *s++;
        } while (0);
        state = L1;
        break;
      }
      case dot:
      case other: {
        do {
          *d++ = *s++;
        } while (0);
        break;
      }
      }
      break;
    }
    }
  }
  *d = '\0';
  return 0;
}


x86 assembly (clang, -O0):
<norm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x870,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x834(%rbp)
movl   $0x0,-0x838(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
cmp    -0x14(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1655 <norm+0x535>
mov    -0x28(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x839(%rbp)
movsbl -0x839(%rbp),%eax
mov    %eax,-0x844(%rbp)
sub    $0x2e,%eax
je     11ca <norm+0xaa>
jmp    11a7 <norm+0x87>
mov    -0x844(%rbp),%eax
sub    $0x2f,%eax
jne    11d9 <norm+0xb9>
jmp    11bb <norm+0x9b>
movl   $0x0,-0x840(%rbp)
jmp    11e3 <norm+0xc3>
movl   $0x1,-0x840(%rbp)
jmp    11e3 <norm+0xc3>
movl   $0x2,-0x840(%rbp)
mov    -0x838(%rbp),%eax
mov    %rax,-0x850(%rbp)
sub    $0x4,%rax
ja     1650 <norm+0x530>
mov    -0x850(%rbp),%rax
lea    0xdf8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x840(%rbp),%eax
mov    %eax,-0x854(%rbp)
test   %eax,%eax
je     1241 <norm+0x121>
jmp    122a <norm+0x10a>
mov    -0x854(%rbp),%eax
add    $0xffffffff,%eax
sub    $0x2,%eax
jb     1277 <norm+0x157>
jmp    128a <norm+0x16a>
jmp    1246 <norm+0x126>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x1,-0x838(%rbp)
jmp    128a <norm+0x16a>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1663 <norm+0x543>
jmp    1650 <norm+0x530>
mov    -0x840(%rbp),%eax
mov    %eax,-0x858(%rbp)
test   %eax,%eax
je     12d0 <norm+0x1b0>
jmp    12a8 <norm+0x188>
mov    -0x858(%rbp),%eax
sub    $0x1,%eax
je     12e6 <norm+0x1c6>
jmp    12bc <norm+0x19c>
mov    -0x858(%rbp),%eax
sub    $0x2,%eax
je     134a <norm+0x22a>
jmp    13a9 <norm+0x289>
jmp    12d5 <norm+0x1b5>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    13a9 <norm+0x289>
jmp    12eb <norm+0x1cb>
jmp    12f0 <norm+0x1d0>
mov    -0x30(%rbp),%rcx
mov    -0x834(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x834(%rbp)
cltq
mov    %rcx,-0x830(%rbp,%rax,8)
ff
jmp    1314 <norm+0x1f4>
jmp    1319 <norm+0x1f9>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x2,-0x838(%rbp)
jmp    13a9 <norm+0x289>
jmp    134f <norm+0x22f>
jmp    1354 <norm+0x234>
mov    -0x30(%rbp),%rcx
mov    -0x834(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x834(%rbp)
cltq
mov    %rcx,-0x830(%rbp,%rax,8)
ff
jmp    1378 <norm+0x258>
jmp    137d <norm+0x25d>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x4,-0x838(%rbp)
jmp    1650 <norm+0x530>
mov    -0x840(%rbp),%eax
mov    %eax,-0x85c(%rbp)
test   %eax,%eax
je     13ef <norm+0x2cf>
jmp    13c7 <norm+0x2a7>
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
je     144a <norm+0x32a>
jmp    13db <norm+0x2bb>
mov    -0x85c(%rbp),%eax
sub    $0x2,%eax
je     1480 <norm+0x360>
jmp    14b1 <norm+0x391>
jmp    13f4 <norm+0x2d4>
jmp    13f9 <norm+0x2d9>
cmpl   $0x0,-0x834(%rbp)
jne    1419 <norm+0x2f9>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1663 <norm+0x543>
mov    -0x834(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x834(%rbp)
cltq
mov    -0x830(%rbp,%rax,8),%rax
ff
mov    %rax,-0x30(%rbp)
jmp    143b <norm+0x31b>
movl   $0x1,-0x838(%rbp)
jmp    14b1 <norm+0x391>
jmp    144f <norm+0x32f>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x3,-0x838(%rbp)
jmp    14b1 <norm+0x391>
jmp    1485 <norm+0x365>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x4,-0x838(%rbp)
jmp    1650 <norm+0x530>
mov    -0x840(%rbp),%eax
mov    %eax,-0x860(%rbp)
test   %eax,%eax
je     14e6 <norm+0x3c6>
jmp    14cf <norm+0x3af>
mov    -0x860(%rbp),%eax
add    $0xffffffff,%eax
sub    $0x2,%eax
jb     1583 <norm+0x463>
jmp    15b4 <norm+0x494>
jmp    14eb <norm+0x3cb>
jmp    14f0 <norm+0x3d0>
cmpl   $0x0,-0x834(%rbp)
jne    1510 <norm+0x3f0>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1663 <norm+0x543>
mov    -0x834(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x834(%rbp)
cltq
mov    -0x830(%rbp,%rax,8),%rax
ff
mov    %rax,-0x30(%rbp)
jmp    1532 <norm+0x412>
cmpl   $0x0,-0x834(%rbp)
jne    1552 <norm+0x432>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1663 <norm+0x543>
mov    -0x834(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x834(%rbp)
cltq
mov    -0x830(%rbp,%rax,8),%rax
ff
mov    %rax,-0x30(%rbp)
jmp    1574 <norm+0x454>
movl   $0x1,-0x838(%rbp)
jmp    15b4 <norm+0x494>
jmp    1588 <norm+0x468>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x4,-0x838(%rbp)
jmp    1650 <norm+0x530>
mov    -0x840(%rbp),%eax
mov    %eax,-0x864(%rbp)
test   %eax,%eax
je     15e9 <norm+0x4c9>
jmp    15d2 <norm+0x4b2>
mov    -0x864(%rbp),%eax
add    $0xffffffff,%eax
sub    $0x2,%eax
jb     161f <norm+0x4ff>
jmp    164b <norm+0x52b>
jmp    15ee <norm+0x4ce>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
movl   $0x1,-0x838(%rbp)
jmp    164b <norm+0x52b>
jmp    1624 <norm+0x504>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    164b <norm+0x52b>
jmp    1650 <norm+0x530>
jmp    1173 <norm+0x53>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x870,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<norm>:
push   %rbp
push   %r14
push   %rbx
sub    $0x800,%rsp
mov    %rdx,%rbx
mov    %esi,%ebp
mov    %rdi,%r14
mov    %rdx,%rdi
call   1030 <strlen@plt>
xor    %edi,%edi
cmp    %ebp,%eax
setle  %dil
call   1040 <assert@plt>
mov    (%rbx),%al
test   %al,%al
je     12db <norm+0x1bb>
xor    %r8d,%r8d
lea    0xea4(%rip),%rcx
xor    %edi,%edi
xor    %r9d,%r9d
mov    %r14,%rsi
jmp    119b <norm+0x7b>
movslq %r9d,%rax
add    $0x1,%r9d
mov    %rsi,(%rsp,%rax,8)
movzbl (%rbx),%eax
add    $0x1,%rbx
mov    %al,(%rsi)
add    $0x1,%rsi
mov    $0x4,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx),%eax
test   %al,%al
je     12d4 <norm+0x1b4>
xor    %edx,%edx
cmp    $0x2e,%al
sete   %dl
mov    $0x2,%ebp
sub    %edx,%ebp
cmp    $0x2f,%al
cmove  %r8d,%ebp
cmp    $0x4,%edi
ja     1190 <norm+0x70>
mov    %edi,%edx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
test   %ebp,%ebp
je     128a <norm+0x16a>
xor    %edi,%edi
add    $0xffffffff,%ebp
cmp    $0x2,%ebp
jae    1190 <norm+0x70>
jmp    12df <norm+0x1bf>
cmp    $0x2,%ebp
je     1166 <norm+0x46>
cmp    $0x1,%ebp
je     129e <norm+0x17e>
mov    $0x1,%edi
test   %ebp,%ebp
jne    1190 <norm+0x70>
add    $0x1,%rbx
jmp    1190 <norm+0x70>
cmp    $0x2,%ebp
je     1174 <norm+0x54>
cmp    $0x1,%ebp
je     12c0 <norm+0x1a0>
mov    $0x2,%edi
test   %ebp,%ebp
jne    1190 <norm+0x70>
test   %r9d,%r9d
je     12df <norm+0x1bf>
movslq %r9d,%rax
add    $0xffffffff,%r9d
mov    -0x8(%rsp,%rax,8),%rsi
mov    $0x1,%edi
jmp    1190 <norm+0x70>
lea    -0x1(%rbp),%edx
cmp    $0x2,%edx
jb     1174 <norm+0x54>
mov    $0x3,%edi
test   %ebp,%ebp
jne    1190 <norm+0x70>
cmp    $0x2,%r9d
jb     12df <norm+0x1bf>
movslq %r9d,%rax
add    $0xfffffffe,%r9d
mov    -0x10(%rsp,%rax,8),%rsi
mov    $0x1,%edi
jmp    1190 <norm+0x70>
mov    $0x4,%edi
lea    -0x1(%rbp),%edx
cmp    $0x2,%edx
jae    1282 <norm+0x162>
add    $0x1,%rbx
mov    %al,(%rsi)
add    $0x1,%rsi
jmp    1190 <norm+0x70>
test   %ebp,%ebp
jne    1190 <norm+0x70>
add    $0x1,%rbx
mov    %al,(%rsi)
add    $0x1,%rsi
mov    $0x1,%edi
jmp    1190 <norm+0x70>
movslq %r9d,%rax
add    $0x1,%r9d
mov    %rsi,(%rsp,%rax,8)
movzbl (%rbx),%eax
add    $0x1,%rbx
mov    %al,(%rsi)
add    $0x1,%rsi
mov    $0x2,%edi
jmp    1190 <norm+0x70>
add    $0x1,%rbx
mov    %al,(%rsi)
add    $0x1,%rsi
mov    $0x3,%edi
jmp    1190 <norm+0x70>
xor    %eax,%eax
mov    %rsi,%r14
jmp    12e4 <norm+0x1c4>
xor    %eax,%eax
jmp    12e4 <norm+0x1c4>
mov    $0xffffffff,%eax
movb   $0x0,(%r14)
add    $0x800,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @norm(i8* %0, i32 %1, i8* %2) {
%4 = alloca [256 x i8*]
%5 = bitcast [256 x i8*]* %4 to i8*
%6 = tail call i32 @strlen(i8* %2)
%7 = icmp sle i32 %6, %1
%8 = zext i1 %7 to i32
%9 = tail call i32 @assert(i32 %8)
%10 = load i8, i8* %2
%11 = icmp eq i8 %10, 0
br i1 %11, label %82, label %12
12: ; preds = %3, %75
%13 = phi i8 [ %80, %75 ], [ %10, %3 ]
%14 = phi i32 [ %79, %75 ], [ 0, %3 ]
%15 = phi i32 [ %78, %75 ], [ 0, %3 ]
%16 = phi i8* [ %77, %75 ], [ %0, %3 ]
%17 = phi i8* [ %76, %75 ], [ %2, %3 ]
%18 = icmp eq i8 %13, 46
%19 = select i1 %18, i32 1, i32 2
%20 = icmp eq i8 %13, 47
%21 = select i1 %20, i32 0, i32 %19
switch i32 %14, label %75 [
i32 0, label %22
i32 1, label %26
i32 2, label %43
i32 3, label %57
i32 4, label %68
]
22: ; preds = %12
switch i32 %21, label %75 [
i32 0, label %23
i32 1, label %82
i32 2, label %82
]
23: ; preds = %22
%24 = getelementptr inbounds i8, i8* %17, i64 1
%25 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %13, i8* %16
br label %75
26: ; preds = %12
switch i32 %21, label %75 [
i32 0, label %27
i32 1, label %29
i32 2, label %36
]
27: ; preds = %26
%28 = getelementptr inbounds i8, i8* %17, i64 1
br label %75
29: ; preds = %26
%30 = add nsw i32 %15, 1
%31 = sext i32 %15 to i64
%32 = getelementptr inbounds [256 x i8*], [256 x i8*]* %4, i64 0, i64 %31
store i8* %16, i8** %32
%33 = getelementptr inbounds i8, i8* %17, i64 1
%34 = load i8, i8* %17
%35 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %34, i8* %16
br label %75
36: ; preds = %26
%37 = add nsw i32 %15, 1
%38 = sext i32 %15 to i64
%39 = getelementptr inbounds [256 x i8*], [256 x i8*]* %4, i64 0, i64 %38
store i8* %16, i8** %39
%40 = getelementptr inbounds i8, i8* %17, i64 1
%41 = load i8, i8* %17
%42 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %41, i8* %16
br label %75
43: ; preds = %12
switch i32 %21, label %75 [
i32 0, label %44
i32 1, label %51
i32 2, label %54
]
44: ; preds = %43
%45 = icmp eq i32 %15, 0
br i1 %45, label %82, label %46
46: ; preds = %44
%47 = add nsw i32 %15, -1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [256 x i8*], [256 x i8*]* %4, i64 0, i64 %48
%50 = load i8*, i8** %49
br label %75
51: ; preds = %43
%52 = getelementptr inbounds i8, i8* %17, i64 1
%53 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %13, i8* %16
br label %75
54: ; preds = %43
%55 = getelementptr inbounds i8, i8* %17, i64 1
%56 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %13, i8* %16
br label %75
57: ; preds = %12
switch i32 %21, label %75 [
i32 0, label %58
i32 1, label %65
i32 2, label %65
]
58: ; preds = %57
%59 = icmp ult i32 %15, 2
br i1 %59, label %82, label %60
60: ; preds = %58
%61 = add nsw i32 %15, -2
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [256 x i8*], [256 x i8*]* %4, i64 0, i64 %62
%64 = load i8*, i8** %63
br label %75
65: ; preds = %57, %57
%66 = getelementptr inbounds i8, i8* %17, i64 1
%67 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %13, i8* %16
br label %75
68: ; preds = %12
switch i32 %21, label %75 [
i32 0, label %69
i32 1, label %72
i32 2, label %72
]
69: ; preds = %68
%70 = getelementptr inbounds i8, i8* %17, i64 1
%71 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %13, i8* %16
br label %75
72: ; preds = %68, %68
%73 = getelementptr inbounds i8, i8* %17, i64 1
%74 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %13, i8* %16
br label %75
75: ; preds = %12, %22, %23, %26, %36, %29, %27, %43, %54, %51, %46, %57, %65, %60, %68, %72, %69
%76 = phi i8* [ %17, %12 ], [ %17, %68 ], [ %73, %72 ], [ %70, %69 ], [ %17, %57 ], [ %66, %65 ], [ %17, %60 ], [ %17, %43 ], [ %55, %54 ], [ %52, %51 ], [ %17, %46 ], [ %17, %26 ], [ %40, %36 ], [ %33, %29 ], [ %28, %27 ], [ %17, %22 ], [ %24, %23 ]
%77 = phi i8* [ %16, %12 ], [ %16, %68 ], [ %74, %72 ], [ %71, %69 ], [ %16, %57 ], [ %67, %65 ], [ %64, %60 ], [ %16, %43 ], [ %56, %54 ], [ %53, %51 ], [ %50, %46 ], [ %16, %26 ], [ %42, %36 ], [ %35, %29 ], [ %16, %27 ], [ %16, %22 ], [ %25, %23 ]
%78 = phi i32 [ %15, %12 ], [ %15, %68 ], [ %15, %72 ], [ %15, %69 ], [ %15, %57 ], [ %15, %65 ], [ %61, %60 ], [ %15, %43 ], [ %15, %54 ], [ %15, %51 ], [ %47, %46 ], [ %15, %26 ], [ %37, %36 ], [ %30, %29 ], [ %15, %27 ], [ %15, %22 ], [ %15, %23 ]
%79 = phi i32 [ %14, %12 ], [ 4, %68 ], [ 4, %72 ], [ 1, %69 ], [ 3, %57 ], [ 4, %65 ], [ 1, %60 ], [ 2, %43 ], [ 4, %54 ], [ 3, %51 ], [ 1, %46 ], [ 1, %26 ], [ 4, %36 ], [ 2, %29 ], [ 1, %27 ], [ 0, %22 ], [ 1, %23 ]
%80 = load i8, i8* %76
%81 = icmp eq i8 %80, 0
br i1 %81, label %82, label %12
82: ; preds = %58, %75, %44, %22, %22, %3
%83 = phi i8* [ %0, %3 ], [ %0, %22 ], [ %0, %22 ], [ %0, %44 ], [ %0, %58 ], [ %77, %75 ]
%84 = phi i32 [ 0, %3 ], [ -1, %22 ], [ -1, %22 ], [ -1, %44 ], [ -1, %58 ], [ 0, %75 ]
store i8 0, i8* %83
ret i32 %84
}