#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 */
scalar_t__ isalnum(unsigned char);
int /*<<< orphan*/ printf(char *, ...);
void encode_table(const char *name) {
  printf("/*\n");
  printf(" * Table has a 0 if that character doesn't need to be encoded;\n");
  printf(" * otherwise it has a string with the character encoded in hex "
         "digits.\n");
  printf(" */\n");
  printf("static char* %s[%d] =\n", name, (1 << 4) * (1 << 4));
  printf("/");
  for (unsigned char r = 0; r < (1 << 4); ++r) {
    printf("%c%5x", r == 0 ? '*' : ' ', r);
  }
  printf(" */\n{\n");
  for (unsigned char r = 0; r < (1 << 4); ++r) {
    unsigned char m = r << 4;
    printf("   ");
    for (unsigned char c = 0; c < (1 << 4); ++c) {
      unsigned char x = m | c;
      int plain = (isalnum(x) || x == '-' || x == '_' || x == '.' || x == '~');
      if (plain) {
        printf("   0 ,");
      } else {
        printf("\"%%%02x\",", (unsigned int)x);
      }
    }
    printf("  /* %1x: %3d ~ %3d */\n", r, m, m + (1 << 4) - 1);
  }
  printf("};\n\n");
}


x86 assembly (clang, -O0):
<encode_table>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xecd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xec3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xef5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf7d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0xf1d(%rip),%rdi
mov    $0x100,%edx
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf21(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movb   $0x0,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
cmp    $0x10,%eax
jge    11cd <encode_table+0xad>
movzbl -0x9(%rbp),%ecx
mov    $0x20,%esi
mov    $0x2a,%eax
cmp    $0x0,%ecx
cmove  %eax,%esi
movzbl -0x9(%rbp),%edx
lea    0xeec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x9(%rbp),%al
add    $0x1,%al
mov    %al,-0x9(%rbp)
jmp    118d <encode_table+0x6d>
lea    0xed7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movb   $0x0,-0xa(%rbp)
movzbl -0xa(%rbp),%eax
cmp    $0x10,%eax
jge    12f9 <encode_table+0x1d9>
movzbl -0xa(%rbp),%eax
shl    $0x4,%eax
mov    %al,-0xb(%rbp)
lea    0xeb5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movb   $0x0,-0xc(%rbp)
movzbl -0xc(%rbp),%eax
cmp    $0x10,%eax
jge    12cc <encode_table+0x1ac>
movzbl -0xb(%rbp),%eax
movzbl -0xc(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0xd(%rbp)
movzbl -0xd(%rbp),%edi
call   1040 <isalnum@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x15(%rbp)
jne    1280 <encode_table+0x160>
movzbl -0xd(%rbp),%ecx
mov    $0x1,%al
cmp    $0x2d,%ecx
mov    %al,-0x15(%rbp)
je     1280 <encode_table+0x160>
movzbl -0xd(%rbp),%ecx
mov    $0x1,%al
cmp    $0x5f,%ecx
mov    %al,-0x15(%rbp)
je     1280 <encode_table+0x160>
movzbl -0xd(%rbp),%ecx
mov    $0x1,%al
cmp    $0x2e,%ecx
mov    %al,-0x15(%rbp)
je     1280 <encode_table+0x160>
movzbl -0xd(%rbp),%eax
cmp    $0x7e,%eax
sete   %al
mov    %al,-0x15(%rbp)
mov    -0x15(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     12a8 <encode_table+0x188>
lea    0xe1a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    12ba <encode_table+0x19a>
movzbl -0xd(%rbp),%esi
lea    0xe0a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    12bf <encode_table+0x19f>
mov    -0xc(%rbp),%al
add    $0x1,%al
mov    %al,-0xc(%rbp)
jmp    1208 <encode_table+0xe8>
movzbl -0xa(%rbp),%esi
movzbl -0xb(%rbp),%edx
movzbl -0xb(%rbp),%ecx
add    $0x10,%ecx
sub    $0x1,%ecx
lea    0xde2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xa(%rbp),%al
add    $0x1,%al
mov    %al,-0xa(%rbp)
jmp    11df <encode_table+0xbf>
lea    0xddf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encode_table>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbx
lea    0xef5(%rip),%rdi
call   1040 <puts@plt>
lea    0xeec(%rip),%rdi
call   1040 <puts@plt>
lea    0xf1f(%rip),%rdi
call   1040 <puts@plt>
lea    0xf5a(%rip),%rdi
call   1040 <puts@plt>
lea    0xe7b(%rip),%rdi
mov    %rbx,%rsi
mov    $0x100,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x2f,%edi
call   1030 <putchar@plt>
lea    0xe72(%rip),%rbx
mov    %rbx,%rdi
mov    $0x2a,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x1,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x2,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x3,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x4,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x5,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x6,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x7,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x8,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0xa,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0xb,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0xc,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0xd,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0xe,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0xf,%edx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdee(%rip),%rdi
call   1040 <puts@plt>
lea    0xd2c(%rip),%rbx
xor    %r13d,%r13d
jmp    1322 <encode_table+0x1e2>
nopw   0x0(%rax,%rax,1)
mov    %ebp,%ecx
or     $0xf,%ecx
lea    0xd26(%rip),%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%r13d
cmp    $0x10,%r13d
je     1397 <encode_table+0x257>
mov    %r13d,%ebp
shl    $0x4,%ebp
xor    %r12d,%r12d
lea    0xceb(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
nopl   0x0(%rax)
mov    %r12d,%r15d
or     %bpl,%r15b
movzbl %r15b,%r14d
mov    %r14d,%edi
call   1060 <isalnum@plt>
test   %rax,%rax
je     1370 <encode_table+0x230>
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%r12b
cmp    $0x10,%r12b
jne    1340 <encode_table+0x200>
jmp    1300 <encode_table+0x1c0>
nopl   (%rax)
lea    -0x2d(%r15),%eax
cmp    $0x2,%al
jb     1357 <encode_table+0x217>
cmp    $0x5f,%r15b
je     1357 <encode_table+0x217>
cmp    $0x7e,%r15b
je     1357 <encode_table+0x217>
lea    0xc9d(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1361 <encode_table+0x221>
lea    0xd3f(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <puts@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"/*\0A\00"
@.str.1 = [64 x i8] c" * Table has a 0 if that character doesn't need to be encoded;\0A\00"
@.str.2 = [72 x i8] c" * otherwise it has a string with the character encoded in hex digits.\0A\00"
@.str.3 = [5 x i8] c" */\0A\00"
@.str.4 = [23 x i8] c"static char* %s[%d] =\0A\00"
@.str.5 = [2 x i8] c"/\00"
@.str.6 = [6 x i8] c"%c%5x\00"
@.str.7 = [7 x i8] c" */\0A{\0A\00"
@.str.8 = [4 x i8] c" \00"
@.str.9 = [7 x i8] c" 0 ,\00"
@.str.10 = [10 x i8] c"\22%%%02x\22,\00"
@.str.11 = [24 x i8] c" /* %1x: %3d ~ %3d */\0A\00"
@.str.12 = [5 x i8] c"};\0A\0A\00"
define void @encode_table(i8* %0) {
%2 = alloca i8*
%3 = alloca i8
%4 = alloca i8
%5 = alloca i8
%6 = alloca i8
%7 = alloca i8
%8 = alloca i32
store i8* %0, i8** %2
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.1, i64 0, i64 0))
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.2, i64 0, i64 0))
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%13 = load i8*, i8** %2
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0), i8* %13, i32 256)
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8 0, i8* %3
br label %16
16: ; preds = %29, %1
%17 = load i8, i8* %3
%18 = zext i8 %17 to i32
%19 = icmp slt i32 %18, 16
br i1 %19, label %20, label %32
20: ; preds = %16
%21 = load i8, i8* %3
%22 = zext i8 %21 to i32
%23 = icmp eq i32 %22, 0
%24 = zext i1 %23 to i64
%25 = select i1 %23, i32 42, i32 32
%26 = load i8, i8* %3
%27 = zext i8 %26 to i32
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 %25, i32 %27)
br label %29
29: ; preds = %20
%30 = load i8, i8* %3
%31 = add i8 %30, 1
store i8 %31, i8* %3
br label %16
32: ; preds = %16
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
store i8 0, i8* %4
br label %34
34: ; preds = %99, %32
%35 = load i8, i8* %4
%36 = zext i8 %35 to i32
%37 = icmp slt i32 %36, 16
br i1 %37, label %38, label %102
38: ; preds = %34
%39 = load i8, i8* %4
%40 = zext i8 %39 to i32
%41 = shl i32 %40, 4
%42 = trunc i32 %41 to i8
store i8 %42, i8* %5
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0))
store i8 0, i8* %6
br label %44
44: ; preds = %86, %38
%45 = load i8, i8* %6
%46 = zext i8 %45 to i32
%47 = icmp slt i32 %46, 16
br i1 %47, label %48, label %89
48: ; preds = %44
%49 = load i8, i8* %5
%50 = zext i8 %49 to i32
%51 = load i8, i8* %6
%52 = zext i8 %51 to i32
%53 = or i32 %50, %52
%54 = trunc i32 %53 to i8
store i8 %54, i8* %7
%55 = load i8, i8* %7
%56 = call i64 @isalnum(i8 zeroext %55)
%57 = icmp ne i64 %56, 0
br i1 %57, label %74, label %58
58: ; preds = %48
%59 = load i8, i8* %7
%60 = zext i8 %59 to i32
%61 = icmp eq i32 %60, 45
br i1 %61, label %74, label %62
62: ; preds = %58
%63 = load i8, i8* %7
%64 = zext i8 %63 to i32
%65 = icmp eq i32 %64, 95
br i1 %65, label %74, label %66
66: ; preds = %62
%67 = load i8, i8* %7
%68 = zext i8 %67 to i32
%69 = icmp eq i32 %68, 46
br i1 %69, label %74, label %70
70: ; preds = %66
%71 = load i8, i8* %7
%72 = zext i8 %71 to i32
%73 = icmp eq i32 %72, 126
br label %74
74: ; preds = %70, %66, %62, %58, %48
%75 = phi i1 [ true, %66 ], [ true, %62 ], [ true, %58 ], [ true, %48 ], [ %73, %70 ]
%76 = zext i1 %75 to i32
store i32 %76, i32* %8
%77 = load i32, i32* %8
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %81
79: ; preds = %74
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
br label %85
81: ; preds = %74
%82 = load i8, i8* %7
%83 = zext i8 %82 to i32
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0), i32 %83)
br label %85
85: ; preds = %81, %79
br label %86
86: ; preds = %85
%87 = load i8, i8* %6
%88 = add i8 %87, 1
store i8 %88, i8* %6
br label %44
89: ; preds = %44
%90 = load i8, i8* %4
%91 = zext i8 %90 to i32
%92 = load i8, i8* %5
%93 = zext i8 %92 to i32
%94 = load i8, i8* %5
%95 = zext i8 %94 to i32
%96 = add nsw i32 %95, 16
%97 = sub nsw i32 %96, 1
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.11, i64 0, i64 0), i32 %91, i32 %93, i32 %97)
br label %99
99: ; preds = %89
%100 = load i8, i8* %4
%101 = add i8 %100, 1
store i8 %101, i8* %4
br label %34
102: ; preds = %34
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str.4 = [23 x i8] c"static char* %s[%d] =\0A\00"
@.str.6 = [6 x i8] c"%c%5x\00"
@.str.8 = [4 x i8] c" \00"
@.str.9 = [7 x i8] c" 0 ,\00"
@.str.10 = [10 x i8] c"\22%%%02x\22,\00"
@.str.11 = [24 x i8] c" /* %1x: %3d ~ %3d */\0A\00"
@str = [3 x i8] c"/*\00"
@str.13 = [63 x i8] c" * Table has a 0 if that character doesn't need to be encoded;\00"
@str.14 = [71 x i8] c" * otherwise it has a string with the character encoded in hex digits.\00"
@str.15 = [4 x i8] c" */\00"
@str.16 = [6 x i8] c" */\0A{\00"
@str.17 = [4 x i8] c"};\0A\00"
define void @encode_table(i8* %0) {
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str, i64 0, i64 0))
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.13, i64 0, i64 0))
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.14, i64 0, i64 0))
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.15, i64 0, i64 0))
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0), i8* %0, i32 256)
%7 = tail call i32 @putchar(i32 47)
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 42, i32 0)
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 1)
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 2)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 3)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 4)
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 5)
%14 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 6)
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 7)
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 8)
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 9)
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 10)
%19 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 11)
%20 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 12)
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 13)
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 14)
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i32 32, i32 15)
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @str.16, i64 0, i64 0))
br label %27
25: ; preds = %32
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
ret void
27: ; preds = %1, %32
%28 = phi i32 [ 0, %1 ], [ %35, %32 ]
%29 = shl nuw i32 %28, 4
%30 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0))
%31 = trunc i32 %29 to i8
br label %37
32: ; preds = %49
%33 = or i32 %29, 15
%34 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.11, i64 0, i64 0), i32 %28, i32 %29, i32 %33)
%35 = add nuw nsw i32 %28, 1
%36 = icmp eq i32 %35, 16
br i1 %36, label %25, label %27
37: ; preds = %27, %49
%38 = phi i8 [ 0, %27 ], [ %50, %49 ]
%39 = or i8 %38, %31
%40 = tail call i64 @isalnum(i8 zeroext %39)
%41 = freeze i64 %40
%42 = icmp eq i64 %41, 0
%43 = zext i8 %39 to i32
br i1 %42, label %44, label %47
44: ; preds = %37
switch i8 %39, label %45 [
i8 95, label %47
i8 46, label %47
i8 45, label %47
i8 126, label %47
]
45: ; preds = %44
%46 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0), i32 %43)
br label %49
47: ; preds = %44, %44, %44, %44, %37
%48 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
br label %49
49: ; preds = %45, %47
%50 = add nuw nsw i8 %38, 1
%51 = icmp eq i8 %50, 16
br i1 %51, label %32, label %37
}