#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*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int range(char *s) {
  int i;
  int j;
  int k;
  int length = strlen(s);
  char b;
  char a;
  char temp[512];
  char printIfErr[] = "entered range is not valid";
  for (i = 0; i < length; i++) {
    if (s[i] == '-' && (i != 0 && i != length - 1)) {
      b = s[i - 1];
      a = s[i + 1];
      if (b > a) {
        fprintf(stderr, "%s\n", printIfErr);
      }
      if (b == a) {
        strcpy(&s[i - 1], &s[i + 1]);
      } else {
        for (j = 0; b < a; b++, j++) {
          temp[j] = b + 1;
        }
        temp[j] = '\0';
        strcpy(&s[i + strlen(temp) - 1], &s[i + 1]);
        for (j = i, k = 0; temp[k] != '\0'; k++, j++) {
          s[j] = temp[k];
        }
      }
      length = strlen(s);
      i += strlen(temp);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<range>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    0xeae(%rip),%rax
mov    %rax,-0x240(%rbp)
mov    0xea8(%rip),%rax
mov    %rax,-0x238(%rbp)
mov    0xea2(%rip),%rax
mov    %rax,-0x230(%rbp)
mov    0xe9c(%rip),%ax
mov    %ax,-0x228(%rbp)
mov    0xe91(%rip),%al
mov    %al,-0x226(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    137b <range+0x24b>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1368 <range+0x238>
cmpl   $0x0,-0xc(%rbp)
je     1368 <range+0x238>
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1368 <range+0x238>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1a(%rbp)
movsbl -0x19(%rbp),%eax
movsbl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jle    1224 <range+0xf4>
mov    0x2dd1(%rip),%rax
mov    (%rax),%edi
lea    -0x240(%rbp),%rdx
lea    0xdfc(%rip),%rsi
call   1050 <fprintf@plt>
movsbl -0x19(%rbp),%eax
movsbl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jne    125c <range+0x12c>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
cltq
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
add    %rax,%rsi
call   1030 <strcpy@plt>
jmp    134a <range+0x21a>
movl   $0x0,-0x10(%rbp)
movsbl -0x19(%rbp),%eax
movsbl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jge    129d <range+0x16d>
movsbl -0x19(%rbp),%eax
add    $0x1,%eax
mov    %al,%cl
movslq -0x10(%rbp),%rax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x19(%rbp),%al
add    $0x1,%al
mov    %al,-0x19(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1263 <range+0x133>
movslq -0x10(%rbp),%rax
movb   $0x0,-0x220(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x244(%rbp)
lea    -0x220(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x250(%rbp),%rdi
mov    %eax,%ecx
mov    -0x244(%rbp),%eax
add    %ecx,%eax
sub    $0x1,%eax
cltq
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movslq -0x14(%rbp),%rax
movsbl -0x220(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     1345 <range+0x215>
movslq -0x14(%rbp),%rax
mov    -0x220(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1303 <range+0x1d3>
jmp    134a <range+0x21a>
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x18(%rbp)
lea    -0x220(%rbp),%rdi
call   1040 <strlen@plt>
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
jmp    136d <range+0x23d>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1196 <range+0x66>
xor    %eax,%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<range>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %rdi,%rbp
call   1040 <strlen@plt>
movups 0xf5b(%rip),%xmm0
movups %xmm0,0x1b(%rsp)
movdqa 0xf43(%rip),%xmm0
movdqa %xmm0,0x10(%rsp)
test   %eax,%eax
jle    14d6 <range+0x3a6>
mov    %eax,%ebx
xor    %r14d,%r14d
pcmpeqd %xmm3,%xmm3
movdqa 0xe94(%rip),%xmm4
movdqa 0xf0c(%rip),%xmm5
movdqa 0xe94(%rip),%xmm6
movdqa 0xe9c(%rip),%xmm7
movdqa 0xea3(%rip),%xmm8
movdqa 0xeaa(%rip),%xmm9
movdqa 0xeb1(%rip),%xmm10
movdqa 0xeb8(%rip),%xmm11
movdqa 0xebf(%rip),%xmm12
jmp    1250 <range+0x120>
cs nopw 0x0(%rax,%rax,1)
add    %rbp,%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebx
lea    0x30(%rsp),%rdi
call   1040 <strlen@plt>
add    %eax,%r14d
pcmpeqd %xmm3,%xmm3
movdqa 0xe12(%rip),%xmm4
movdqa 0xe8a(%rip),%xmm5
movdqa 0xe12(%rip),%xmm6
movdqa 0xe1a(%rip),%xmm7
movdqa 0xe21(%rip),%xmm8
movdqa 0xe28(%rip),%xmm9
movdqa 0xe2f(%rip),%xmm10
movdqa 0xe36(%rip),%xmm11
movdqa 0xe3d(%rip),%xmm12
add    $0x1,%r14d
cmp    %ebx,%r14d
jge    14d6 <range+0x3a6>
movslq %r14d,%r15
cmpb   $0x2d,0x0(%rbp,%r15,1)
jne    1243 <range+0x113>
test   %r14d,%r14d
je     1243 <range+0x113>
lea    -0x1(%rbx),%eax
cmp    %eax,%r14d
je     1243 <range+0x113>
lea    -0x1(%r14),%eax
mov    %eax,0x4(%rsp)
movslq %eax,%rbx
mov    0x0(%rbp,%rbx,1),%r13b
mov    0x1(%r15,%rbp,1),%r12b
cmp    %r13b,%r12b
jge    12ed <range+0x1bd>
mov    0x2d57(%rip),%rax
mov    (%rax),%edi
lea    0xe29(%rip),%rsi
lea    0x10(%rsp),%rdx
call   1050 <fprintf@plt>
movdqa 0xddb(%rip),%xmm12
movdqa 0xdc2(%rip),%xmm11
movdqa 0xda9(%rip),%xmm10
movdqa 0xd90(%rip),%xmm9
movdqa 0xd77(%rip),%xmm8
movdqa 0xd5f(%rip),%xmm7
movdqa 0xd47(%rip),%xmm6
movdqa 0xdaf(%rip),%xmm5
movdqa 0xd27(%rip),%xmm4
pcmpeqd %xmm3,%xmm3
lea    (%r15,%rbp,1),%rsi
add    $0x1,%rsi
mov    %r12d,%ecx
sub    %r13b,%cl
je     11d0 <range+0xa0>
mov    %rsi,0x8(%rsp)
jle    1321 <range+0x1f1>
mov    %r13d,%eax
not    %al
add    %al,%r12b
cmp    $0x1f,%r12b
jae    132c <range+0x1fc>
xor    %eax,%eax
mov    0x4(%rsp),%ebx
jmp    1464 <range+0x334>
xor    %eax,%eax
mov    0x4(%rsp),%ebx
jmp    1481 <range+0x351>
movzbl %r12b,%edx
add    $0x1,%rdx
mov    %edx,%eax
and    $0xffffffe0,%eax
movzbl %r13b,%esi
movd   %esi,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddb  0xca9(%rip),%xmm0
lea    -0x20(%rax),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0x60,%rdi
jae    1378 <range+0x248>
xor    %edi,%edi
jmp    1410 <range+0x2e0>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movdqa %xmm0,%xmm1
psubb  %xmm3,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm4,%xmm2
movdqa %xmm1,0x30(%rsp,%rdi,1)
movdqa %xmm2,0x40(%rsp,%rdi,1)
movdqa %xmm0,%xmm1
paddb  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm7,%xmm2
movdqa %xmm1,0x50(%rsp,%rdi,1)
movdqa %xmm2,0x60(%rsp,%rdi,1)
movdqa %xmm0,%xmm1
paddb  %xmm8,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm9,%xmm2
movdqa %xmm1,0x70(%rsp,%rdi,1)
movdqa %xmm2,0x80(%rsp,%rdi,1)
movdqa %xmm0,%xmm1
paddb  %xmm10,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm11,%xmm2
movdqa %xmm1,0x90(%rsp,%rdi,1)
movdqa %xmm2,0xa0(%rsp,%rdi,1)
sub    $0xffffffffffffff80,%rdi
pxor   %xmm12,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1380 <range+0x250>
test   %rbx,%rbx
je     1458 <range+0x328>
lea    0x40(%rsp),%rsi
add    %rsi,%rdi
shl    $0x5,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm1
psubb  %xmm3,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm4,%xmm2
movdqa %xmm1,-0x10(%rdi,%rsi,1)
movdqa %xmm2,(%rdi,%rsi,1)
paddb  %xmm5,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    1430 <range+0x300>
cmp    %rax,%rdx
mov    0x4(%rsp),%ebx
je     1481 <range+0x351>
add    %al,%r13b
movzbl %cl,%ecx
add    $0x1,%r13b
nopl   0x0(%rax,%rax,1)
mov    %r13b,0x30(%rsp,%rax,1)
add    $0x1,%rax
add    $0x1,%r13b
cmp    %al,%cl
jne    1470 <range+0x340>
mov    %eax,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rdi
call   1040 <strlen@plt>
add    %eax,%ebx
movslq %ebx,%rdi
add    %rbp,%rdi
mov    0x8(%rsp),%rsi
call   1030 <strcpy@plt>
mov    0x30(%rsp),%al
test   %al,%al
je     11db <range+0xab>
add    %rbp,%r15
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %al,(%r15,%rcx,1)
movzbl 0x31(%rsp,%rcx,1),%eax
add    $0x1,%rcx
test   %al,%al
jne    14c0 <range+0x390>
jmp    11db <range+0xab>
xor    %eax,%eax
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.range.printIfErr = [27 x i8] c"entered range is not valid\00"
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
define i32 @range(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8
%8 = alloca i8
%9 = alloca [512 x i8]
%10 = alloca [27 x i8]
store i8* %0, i8** %2
%11 = load i8*, i8** %2
%12 = call i32 @strlen(i8* %11)
store i32 %12, i32* %6
%13 = bitcast [27 x i8]* %10 to i8*
store i32 0, i32* %3
br label %14
14: ; preds = %143, %1
%15 = load i32, i32* %3
%16 = load i32, i32* %6
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %146
18: ; preds = %14
%19 = load i8*, i8** %2
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = icmp eq i32 %24, 45
br i1 %25, label %26, label %142
26: ; preds = %18
%27 = load i32, i32* %3
%28 = icmp ne i32 %27, 0
br i1 %28, label %29, label %142
29: ; preds = %26
%30 = load i32, i32* %3
%31 = load i32, i32* %6
%32 = sub nsw i32 %31, 1
%33 = icmp ne i32 %30, %32
br i1 %33, label %34, label %142
34: ; preds = %29
%35 = load i8*, i8** %2
%36 = load i32, i32* %3
%37 = sub nsw i32 %36, 1
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %35, i64 %38
%40 = load i8, i8* %39
store i8 %40, i8* %7
%41 = load i8*, i8** %2
%42 = load i32, i32* %3
%43 = add nsw i32 %42, 1
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %41, i64 %44
%46 = load i8, i8* %45
store i8 %46, i8* %8
%47 = load i8, i8* %7
%48 = sext i8 %47 to i32
%49 = load i8, i8* %8
%50 = sext i8 %49 to i32
%51 = icmp sgt i32 %48, %50
br i1 %51, label %52, label %56
52: ; preds = %34
%53 = load i32, i32* @stderr
%54 = getelementptr inbounds [27 x i8], [27 x i8]* %10, i64 0, i64 0
%55 = call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %54)
br label %56
56: ; preds = %52, %34
%57 = load i8, i8* %7
%58 = sext i8 %57 to i32
%59 = load i8, i8* %8
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %58, %60
br i1 %61, label %62, label %74
62: ; preds = %56
%63 = load i8*, i8** %2
%64 = load i32, i32* %3
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %63, i64 %66
%68 = load i8*, i8** %2
%69 = load i32, i32* %3
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %68, i64 %71
%73 = call i32 @strcpy(i8* %67, i8* %72)
br label %135
74: ; preds = %56
store i32 0, i32* %4
br label %75
75: ; preds = %89, %74
%76 = load i8, i8* %7
%77 = sext i8 %76 to i32
%78 = load i8, i8* %8
%79 = sext i8 %78 to i32
%80 = icmp slt i32 %77, %79
br i1 %80, label %81, label %94
81: ; preds = %75
%82 = load i8, i8* %7
%83 = sext i8 %82 to i32
%84 = add nsw i32 %83, 1
%85 = trunc i32 %84 to i8
%86 = load i32, i32* %4
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %87
store i8 %85, i8* %88
br label %89
89: ; preds = %81
%90 = load i8, i8* %7
%91 = add i8 %90, 1
store i8 %91, i8* %7
%92 = load i32, i32* %4
%93 = add nsw i32 %92, 1
store i32 %93, i32* %4
br label %75
94: ; preds = %75
%95 = load i32, i32* %4
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %96
store i8 0, i8* %97
%98 = load i8*, i8** %2
%99 = load i32, i32* %3
%100 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%101 = call i32 @strlen(i8* %100)
%102 = add nsw i32 %99, %101
%103 = sub nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %98, i64 %104
%106 = load i8*, i8** %2
%107 = load i32, i32* %3
%108 = add nsw i32 %107, 1
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %106, i64 %109
%111 = call i32 @strcpy(i8* %105, i8* %110)
%112 = load i32, i32* %3
store i32 %112, i32* %4
store i32 0, i32* %5
br label %113
113: ; preds = %129, %94
%114 = load i32, i32* %5
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %115
%117 = load i8, i8* %116
%118 = sext i8 %117 to i32
%119 = icmp ne i32 %118, 0
br i1 %119, label %120, label %134
120: ; preds = %113
%121 = load i32, i32* %5
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %122
%124 = load i8, i8* %123
%125 = load i8*, i8** %2
%126 = load i32, i32* %4
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %125, i64 %127
store i8 %124, i8* %128
br label %129
129: ; preds = %120
%130 = load i32, i32* %5
%131 = add nsw i32 %130, 1
store i32 %131, i32* %5
%132 = load i32, i32* %4
%133 = add nsw i32 %132, 1
store i32 %133, i32* %4
br label %113
134: ; preds = %113
br label %135
135: ; preds = %134, %62
%136 = load i8*, i8** %2
%137 = call i32 @strlen(i8* %136)
store i32 %137, i32* %6
%138 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%139 = call i32 @strlen(i8* %138)
%140 = load i32, i32* %3
%141 = add nsw i32 %140, %139
store i32 %141, i32* %3
br label %142
142: ; preds = %135, %29, %26, %18
br label %143
143: ; preds = %142
%144 = load i32, i32* %3
%145 = add nsw i32 %144, 1
store i32 %145, i32* %3
br label %14
146: ; preds = %14
ret i32 0
}

LLVM IR (-O2):
@__const.range.printIfErr = [27 x i8] c"entered range is not valid\00"
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
define i32 @range(i8* %0) {
%2 = alloca [512 x i8]
%3 = alloca [27 x i8]
%4 = tail call i32 @strlen(i8* %0)
%5 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%6 = getelementptr inbounds [27 x i8], [27 x i8]* %3, i64 0, i64 0
%7 = icmp sgt i32 %4, 0
br i1 %7, label %8, label %156
8: ; preds = %1, %151
%9 = phi i32 [ %154, %151 ], [ 0, %1 ]
%10 = phi i32 [ %152, %151 ], [ %4, %1 ]
%11 = sext i32 %9 to i64
%12 = getelementptr inbounds i8, i8* %0, i64 %11
%13 = load i8, i8* %12
%14 = icmp ne i8 %13, 45
%15 = icmp eq i32 %9, 0
%16 = select i1 %14, i1 true, i1 %15
%17 = add nsw i32 %10, -1
%18 = icmp eq i32 %9, %17
%19 = select i1 %16, i1 true, i1 %18
br i1 %19, label %151, label %20
20: ; preds = %8
%21 = add i32 %9, -1
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %0, i64 %22
%24 = load i8, i8* %23
%25 = add nsw i32 %9, 1
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %0, i64 %26
%28 = load i8, i8* %27
%29 = icmp slt i8 %28, %24
br i1 %29, label %30, label %33
30: ; preds = %20
%31 = load i32, i32* @stderr
%32 = call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %6)
br label %33
33: ; preds = %30, %20
%34 = icmp eq i8 %28, %24
br i1 %34, label %116, label %35
35: ; preds = %33
%36 = icmp sgt i8 %28, %24
br i1 %36, label %37, label %126
37: ; preds = %35
%38 = sub i8 %28, %24
%39 = xor i8 %24, -1
%40 = add i8 %28, %39
%41 = zext i8 %40 to i64
%42 = add nuw nsw i64 %41, 1
%43 = icmp ult i8 %40, 31
br i1 %43, label %113, label %44
44: ; preds = %37
%45 = and i64 %42, 480
%46 = trunc i64 %45 to i8
%47 = add i8 %24, %46
%48 = insertelement <16 x i8> poison, i8 %24, i64 0
%49 = shufflevector <16 x i8> %48, <16 x i8> poison, <16 x i32> zeroinitializer
%50 = add <16 x i8> %49, <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>
%51 = add nsw i64 %45, -32
%52 = lshr exact i64 %51, 5
%53 = add nuw nsw i64 %52, 1
%54 = and i64 %53, 3
%55 = icmp ult i64 %51, 96
br i1 %55, label %93, label %56
56: ; preds = %44
%57 = and i64 %53, 1152921504606846972
br label %58
58: ; preds = %58, %56
%59 = phi i64 [ 0, %56 ], [ %89, %58 ]
%60 = phi <16 x i8> [ %50, %56 ], [ %90, %58 ]
%61 = phi i64 [ 0, %56 ], [ %91, %58 ]
%62 = add nsw <16 x i8> %60, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%63 = add <16 x i8> %60, <i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17>
%64 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %59
%65 = bitcast i8* %64 to <16 x i8>*
store <16 x i8> %62, <16 x i8>* %65
%66 = getelementptr inbounds i8, i8* %64, i64 16
%67 = bitcast i8* %66 to <16 x i8>*
store <16 x i8> %63, <16 x i8>* %67
%68 = or i64 %59, 32
%69 = add <16 x i8> %60, <i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33, i8 33>
%70 = add <16 x i8> %60, <i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49>
%71 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %68
%72 = bitcast i8* %71 to <16 x i8>*
store <16 x i8> %69, <16 x i8>* %72
%73 = getelementptr inbounds i8, i8* %71, i64 16
%74 = bitcast i8* %73 to <16 x i8>*
store <16 x i8> %70, <16 x i8>* %74
%75 = or i64 %59, 64
%76 = add <16 x i8> %60, <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>
%77 = add <16 x i8> %60, <i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81>
%78 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %75
%79 = bitcast i8* %78 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %79
%80 = getelementptr inbounds i8, i8* %78, i64 16
%81 = bitcast i8* %80 to <16 x i8>*
store <16 x i8> %77, <16 x i8>* %81
%82 = or i64 %59, 96
%83 = add <16 x i8> %60, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%84 = add <16 x i8> %60, <i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113>
%85 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %82
%86 = bitcast i8* %85 to <16 x i8>*
store <16 x i8> %83, <16 x i8>* %86
%87 = getelementptr inbounds i8, i8* %85, i64 16
%88 = bitcast i8* %87 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %88
%89 = add nuw i64 %59, 128
%90 = xor <16 x i8> %60, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%91 = add i64 %61, 4
%92 = icmp eq i64 %91, %57
br i1 %92, label %93, label %58
93: ; preds = %58, %44
%94 = phi i64 [ 0, %44 ], [ %89, %58 ]
%95 = phi <16 x i8> [ %50, %44 ], [ %90, %58 ]
%96 = icmp eq i64 %54, 0
br i1 %96, label %111, label %97
97: ; preds = %93, %97
%98 = phi i64 [ %107, %97 ], [ %94, %93 ]
%99 = phi <16 x i8> [ %108, %97 ], [ %95, %93 ]
%100 = phi i64 [ %109, %97 ], [ 0, %93 ]
%101 = add nsw <16 x i8> %99, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%102 = add <16 x i8> %99, <i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17, i8 17>
%103 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %98
%104 = bitcast i8* %103 to <16 x i8>*
store <16 x i8> %101, <16 x i8>* %104
%105 = getelementptr inbounds i8, i8* %103, i64 16
%106 = bitcast i8* %105 to <16 x i8>*
store <16 x i8> %102, <16 x i8>* %106
%107 = add nuw i64 %98, 32
%108 = add <16 x i8> %99, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%109 = add i64 %100, 1
%110 = icmp eq i64 %109, %54
br i1 %110, label %111, label %97
111: ; preds = %97, %93
%112 = icmp eq i64 %42, %45
br i1 %112, label %126, label %113
113: ; preds = %37, %111
%114 = phi i64 [ 0, %37 ], [ %45, %111 ]
%115 = phi i8 [ %24, %37 ], [ %47, %111 ]
br label %118
116: ; preds = %33
%117 = call i32 @strcpy(i8* %23, i8* %27)
br label %147
118: ; preds = %113, %118
%119 = phi i64 [ %123, %118 ], [ %114, %113 ]
%120 = phi i8 [ %121, %118 ], [ %115, %113 ]
%121 = add nsw i8 %120, 1
%122 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %119
store i8 %121, i8* %122
%123 = add nuw nsw i64 %119, 1
%124 = trunc i64 %123 to i8
%125 = icmp eq i8 %38, %124
br i1 %125, label %126, label %118
126: ; preds = %118, %111, %35
%127 = phi i64 [ 0, %35 ], [ %45, %111 ], [ %123, %118 ]
%128 = and i64 %127, 4294967295
%129 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %128
store i8 0, i8* %129
%130 = call i32 @strlen(i8* %5)
%131 = add i32 %21, %130
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i8, i8* %0, i64 %132
%134 = call i32 @strcpy(i8* %133, i8* %27)
%135 = load i8, i8* %5
%136 = icmp eq i8 %135, 0
br i1 %136, label %147, label %137
137: ; preds = %126, %137
%138 = phi i64 [ %143, %137 ], [ %11, %126 ]
%139 = phi i64 [ %142, %137 ], [ 0, %126 ]
%140 = phi i8 [ %145, %137 ], [ %135, %126 ]
%141 = getelementptr inbounds i8, i8* %0, i64 %138
store i8 %140, i8* %141
%142 = add nuw nsw i64 %139, 1
%143 = add i64 %138, 1
%144 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 %142
%145 = load i8, i8* %144
%146 = icmp eq i8 %145, 0
br i1 %146, label %147, label %137
147: ; preds = %137, %126, %116
%148 = call i32 @strlen(i8* %0)
%149 = call i32 @strlen(i8* %5)
%150 = add nsw i32 %149, %9
br label %151
151: ; preds = %8, %147
%152 = phi i32 [ %148, %147 ], [ %10, %8 ]
%153 = phi i32 [ %150, %147 ], [ %9, %8 ]
%154 = add nsw i32 %153, 1
%155 = icmp slt i32 %154, %152
br i1 %155, label %8, label %156
156: ; preds = %151, %1
ret i32 0
}