#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__ isalpha(char);
scalar_t__ isdigit(char);
char tolower(char);
void expand(char s1[], char s2[]) {
  int i, j;
  char start = 0;
  char end = 0;
  for (i = 0, j = 0; s1[i] != '\0'; i++) {
    if (s1[i] == '-') {
      if ((isalpha(s1[i - 1]) && isalpha(s1[i + 1])) ||
          (isdigit(s1[i - 1]) && isdigit(s1[i + 1]))) {
        start = s1[i - 1];
        end = s1[i + 1];
        start = tolower(start);
        end = tolower(end);
        if (start == s2[j - 1]) {
          start++;
        }
        while (start <= end) {
          s2[j++] = start++;
        }
      } else {
        if (i == 0 || s1[i + 1] == '\0') {
          s2[j++] = '-';
        }
      }
    }
  }
  s2[j] = '\0';
}


x86 assembly (clang, -O0):
<expand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movb   $0x0,-0x19(%rbp)
movb   $0x0,-0x1a(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     12f8 <expand+0x1c8>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    12e5 <expand+0x1b5>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
je     11c0 <expand+0x90>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
jne    1200 <expand+0xd0>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12a1 <expand+0x171>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12a1 <expand+0x171>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1a(%rbp)
movsbl -0x19(%rbp),%edi
call   1040 <tolower@plt>
mov    %al,-0x19(%rbp)
movsbl -0x1a(%rbp),%edi
call   1040 <tolower@plt>
mov    %al,-0x1a(%rbp)
movsbl -0x19(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1263 <expand+0x133>
mov    -0x19(%rbp),%al
add    $0x1,%al
mov    %al,-0x19(%rbp)
jmp    1268 <expand+0x138>
movsbl -0x19(%rbp),%eax
movsbl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jg     129c <expand+0x16c>
mov    -0x19(%rbp),%dl
mov    %dl,%al
add    $0x1,%al
mov    %al,-0x19(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1268 <expand+0x138>
jmp    12e0 <expand+0x1b0>
cmpl   $0x0,-0x14(%rbp)
je     12c5 <expand+0x195>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    12db <expand+0x1ab>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
movb   $0x2d,(%rax,%rcx,1)
jmp    12e0 <expand+0x1b0>
jmp    12e5 <expand+0x1b5>
jmp    12ea <expand+0x1ba>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1156 <expand+0x26>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<expand>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r15
mov    %rdi,%r14
lea    0x70(%rsi),%rax
mov    %rax,0x8(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
xor    %r13d,%r13d
jmp    116c <expand+0x3c>
xchg   %ax,%ax
test   %al,%al
je     13cb <expand+0x29b>
add    $0x1,%r12
mov    (%r14,%r12,1),%al
cmp    $0x2d,%al
jne    1160 <expand+0x30>
movsbl -0x1(%r12,%r14,1),%edi
call   1050 <isalpha@plt>
test   %rax,%rax
je     1198 <expand+0x68>
lea    0x1(%r12),%ebx
movsbl (%r14,%rbx,1),%edi
call   1050 <isalpha@plt>
test   %rax,%rax
jne    11c4 <expand+0x94>
movsbl -0x1(%r14,%r12,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12ad <expand+0x17d>
lea    0x1(%r12),%ebx
movsbl (%r14,%rbx,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12ad <expand+0x17d>
movsbl -0x1(%r14,%r12,1),%edi
movsbl (%r14,%rbx,1),%ebp
call   1040 <tolower@plt>
mov    %eax,%ebx
mov    %ebp,%edi
call   1040 <tolower@plt>
movslq %r13d,%rcx
cmp    -0x1(%rcx,%r15,1),%bl
sete   %sil
lea    (%rbx,%rsi,1),%edx
cmp    %al,%dl
movdqa 0xe1a(%rip),%xmm3
movdqa 0xe22(%rip),%xmm4
movdqa 0xe2a(%rip),%xmm5
movdqa 0xe32(%rip),%xmm6
movdqa 0xe3a(%rip),%xmm7
movdqa 0xe41(%rip),%xmm8
movdqa 0xe48(%rip),%xmm9
movdqa 0xe4f(%rip),%xmm10
jg     1168 <expand+0x38>
lea    (%rbx,%rsi,1),%edi
add    $0x1,%dil
lea    0x1(%rax),%ebp
movzbl %dil,%edi
movzbl %bpl,%ebp
cmp    %bpl,%dil
cmovg  %edi,%ebp
not    %bl
add    %bpl,%bl
sub    %sil,%bl
cmp    $0x1f,%bl
jb     13b0 <expand+0x280>
movzbl %bl,%r8d
add    $0x1,%r8
mov    %r8d,%r9d
and    $0xffffffe0,%r9d
movzbl %dl,%esi
movd   %esi,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddb  0xd74(%rip),%xmm0
lea    -0x20(%r9),%rdi
mov    %rdi,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%esi
and    $0x3,%esi
cmp    $0x60,%rdi
jae    12d3 <expand+0x1a3>
xor    %ebx,%ebx
jmp    1368 <expand+0x238>
test   %r12,%r12
je     12c2 <expand+0x192>
lea    0x1(%r12),%eax
cmpb   $0x0,(%r14,%rax,1)
jne    1168 <expand+0x38>
movslq %r13d,%rax
add    $0x1,%r13d
movb   $0x2d,(%r15,%rax,1)
jmp    1168 <expand+0x38>
and    $0xfffffffffffffffc,%rbp
mov    0x8(%rsp),%rdi
add    %rcx,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm3,%xmm1
movdqu %xmm0,-0x70(%rdi,%rbx,1)
movdqu %xmm1,-0x60(%rdi,%rbx,1)
movdqa %xmm0,%xmm1
paddb  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm5,%xmm2
movdqu %xmm1,-0x50(%rdi,%rbx,1)
movdqu %xmm2,-0x40(%rdi,%rbx,1)
movdqa %xmm0,%xmm1
paddb  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm7,%xmm2
movdqu %xmm1,-0x30(%rdi,%rbx,1)
movdqu %xmm2,-0x20(%rdi,%rbx,1)
movdqa %xmm0,%xmm1
paddb  %xmm8,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm9,%xmm2
movdqu %xmm1,-0x10(%rdi,%rbx,1)
movdqu %xmm2,(%rdi,%rbx,1)
sub    $0xffffffffffffff80,%rbx
pxor   %xmm10,%xmm0
add    $0xfffffffffffffffc,%rbp
jne    12f0 <expand+0x1c0>
test   %rsi,%rsi
je     13a0 <expand+0x270>
add    %rcx,%rbx
add    0x10(%rsp),%rbx
shl    $0x5,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm3,%xmm1
movdqu %xmm0,-0x10(%rbx,%rdi,1)
movdqu %xmm1,(%rbx,%rdi,1)
paddb  %xmm4,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1380 <expand+0x250>
add    %r9,%rcx
cmp    %r9,%r8
je     13bf <expand+0x28f>
add    %r9b,%dl
nopl   0x0(%rax,%rax,1)
mov    %dl,(%r15,%rcx,1)
add    $0x1,%rcx
add    $0x1,%dl
cmp    %al,%dl
jle    13b0 <expand+0x280>
mov    %ecx,%r13d
add    $0x1,%r12
jmp    116c <expand+0x3c>
movslq %r13d,%rax
movb   $0x0,(%r15,%rax,1)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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