#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(int);
scalar_t__ isdigit(int);
int tolower(char);
void expand(char s1[], char s2[]) {
  int i, j, k, c;
  i = j = k = 0;
  int inSeqNum = 0;
  int inSeqCh = 0;
  int last;
  while (s1[i]) {
    if (inSeqNum) {
      inSeqNum = 0;
      if (isdigit(s1[i]) && (last < s1[i])) {
        for (k = last + 1; k <= s1[i]; k++)
          s2[j++] = k;
        last = -1;
      } else {
        if (j + 3 >= 1000) {
          s2[j] = '\0';
          return;
        }
        s2[j++] = '-';
        s2[j++] = s1[i];
        last = s1[i];
      }
    } else if (inSeqCh) {
      inSeqCh = 0;
      k = tolower(last);
      c = tolower(s1[i]);
      if (isalpha(s1[i]) && (k < c)) {
        for (k++; k < c; k++)
          s2[j++] = k;
        s2[j++] = s1[i];
        last = -1;
      } else {
        if (j + 3 >= 1000) {
          s2[j] = '\0';
          return;
        }
        s2[j++] = '-';
        s2[j++] = s1[i];
        last = s1[i];
      }
    } else if (s1[i] == '-') {
      if (isdigit(last))
        inSeqNum = 1;
      else if (isalpha(last))
        inSeqCh = 1;
      else
        s2[j++] = '-';
    } else {
      last = s1[i];
      s2[j++] = s1[i];
    }
    i++;
  }
  if (inSeqCh || inSeqNum) {
    if (j + 2 >= 1000) {
      s2[j] = '\0';
      return;
    }
    s2[j++] = last;
    s2[j++] = '-';
  }
  if (j == 1000) {
    s2[j - 1] = '\0';
    return;
  }
  s2[j] = '\0';
}


x86 assembly (clang, -O0):
<expand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     145f <expand+0x32f>
cmpl   $0x0,-0x24(%rbp)
je     1278 <expand+0x148>
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     120c <expand+0xdc>
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jge    120c <expand+0xdc>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     1200 <expand+0xd0>
mov    -0x1c(%rbp),%eax
mov    %al,%dl
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)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c1 <expand+0x91>
movl   $0xffffffff,-0x2c(%rbp)
jmp    1273 <expand+0x143>
mov    -0x18(%rbp),%eax
add    $0x3,%eax
cmp    $0x3e8,%eax
jl     122e <expand+0xfe>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    14f4 <expand+0x3c4>
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)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
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)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x2c(%rbp)
jmp    1451 <expand+0x321>
cmpl   $0x0,-0x28(%rbp)
je     13a7 <expand+0x277>
movl   $0x0,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
movsbl %al,%edi
call   1040 <tolower@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
je     133b <expand+0x20b>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    133b <expand+0x20b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    130f <expand+0x1df>
mov    -0x1c(%rbp),%eax
mov    %al,%dl
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)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12db <expand+0x1ab>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
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)
movl   $0xffffffff,-0x2c(%rbp)
jmp    13a2 <expand+0x272>
mov    -0x18(%rbp),%eax
add    $0x3,%eax
cmp    $0x3e8,%eax
jl     135d <expand+0x22d>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    14f4 <expand+0x3c4>
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)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
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)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x2c(%rbp)
jmp    144c <expand+0x31c>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1418 <expand+0x2e8>
mov    -0x2c(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13da <expand+0x2aa>
movl   $0x1,-0x24(%rbp)
jmp    1413 <expand+0x2e3>
mov    -0x2c(%rbp),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
je     13f8 <expand+0x2c8>
movl   $0x1,-0x28(%rbp)
jmp    140e <expand+0x2de>
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    1413 <expand+0x2e3>
jmp    1447 <expand+0x317>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
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    144c <expand+0x31c>
jmp    1451 <expand+0x321>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1163 <expand+0x33>
cmpl   $0x0,-0x28(%rbp)
jne    1473 <expand+0x343>
cmpl   $0x0,-0x24(%rbp)
je     14c5 <expand+0x395>
mov    -0x18(%rbp),%eax
add    $0x2,%eax
cmp    $0x3e8,%eax
jl     1495 <expand+0x365>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    14f4 <expand+0x3c4>
mov    -0x2c(%rbp),%eax
mov    %al,%dl
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)
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)
cmpl   $0x3e8,-0x18(%rbp)
jne    14e8 <expand+0x3b8>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    14f4 <expand+0x3c4>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x30,%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),%cl
test   %cl,%cl
je     149f <expand+0x36f>
lea    0x70(%r15),%rax
mov    %rax,0x8(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x10(%rsp)
xor    %r13d,%r13d
mov    %rdi,%r14
xor    %r12d,%r12d
xor    %eax,%eax
xor    %ebx,%ebx
mov    %rdi,(%rsp)
jmp    11a0 <expand+0x70>
mov    (%r14),%al
movslq %ebx,%rcx
add    $0x1,%ebx
mov    %al,(%r15,%rcx,1)
mov    $0xffffffff,%ebp
xor    %eax,%eax
xor    %r12d,%r12d
lea    (%rdi,%r13,1),%r14
add    $0x1,%r14
mov    0x1(%rdi,%r13,1),%cl
add    $0x1,%r13
test   %cl,%cl
je     148e <expand+0x35e>
test   %eax,%eax
je     1220 <expand+0xf0>
movsbl %cl,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     11f0 <expand+0xc0>
movsbl (%r14),%eax
cmp    %eax,%ebp
jge    11f0 <expand+0xc0>
movslq %ebx,%rax
add    %r15,%rax
mov    (%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebp
mov    %bpl,(%rax)
movsbl (%r14),%ecx
add    $0x1,%rax
add    $0x1,%ebx
cmp    %ecx,%ebp
jl     11d0 <expand+0xa0>
mov    $0xffffffff,%ebp
xor    %eax,%eax
jmp    1187 <expand+0x57>
xchg   %ax,%ax
cmp    $0x3e5,%ebx
mov    (%rsp),%rdi
jge    149b <expand+0x36b>
movslq %ebx,%rax
movb   $0x2d,(%r15,%rax,1)
mov    (%r14),%cl
add    $0x2,%ebx
mov    %cl,0x1(%r15,%rax,1)
movsbl (%r14),%ebp
xor    %eax,%eax
jmp    1187 <expand+0x57>
xchg   %ax,%ax
test   %r12d,%r12d
je     130f <expand+0x1df>
movsbl %bpl,%edi
call   1040 <tolower@plt>
mov    %eax,%ebp
movsbl (%r14),%edi
call   1040 <tolower@plt>
mov    %eax,%r12d
movsbl (%r14),%edi
call   1050 <isalpha@plt>
test   %rax,%rax
je     1331 <expand+0x201>
cmp    %r12d,%ebp
jge    1331 <expand+0x201>
lea    0x1(%rbp),%eax
cmp    %r12d,%eax
mov    (%rsp),%rdi
jge    1170 <expand+0x40>
movslq %ebx,%rbx
mov    %r12d,%r9d
sub    %ebp,%r9d
add    $0xfffffffe,%r9d
cmp    $0x1f,%r9d
movdqa 0xd8c(%rip),%xmm3
movdqa 0xd94(%rip),%xmm4
movdqa 0xd9b(%rip),%xmm8
movdqa 0xda2(%rip),%xmm9
movdqa 0xda9(%rip),%xmm10
movdqa 0xdb1(%rip),%xmm5
movdqa 0xdb9(%rip),%xmm6
movdqa 0xdc1(%rip),%xmm7
jb     1460 <expand+0x330>
add    $0x1,%r9
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
movd   %eax,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddb  0xd16(%rip),%xmm0
lea    -0x20(%r8),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x60,%rdx
jae    1390 <expand+0x260>
xor    %ecx,%ecx
jmp    1418 <expand+0x2e8>
cmp    $0x2d,%cl
jne    135d <expand+0x22d>
mov    %ebp,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     136f <expand+0x23f>
xor    %r12d,%r12d
mov    $0x1,%eax
mov    (%rsp),%rdi
jmp    1187 <expand+0x57>
cmp    $0x3e5,%ebx
mov    (%rsp),%rdi
jge    149b <expand+0x36b>
movslq %ebx,%rax
movb   $0x2d,(%r15,%rax,1)
mov    (%r14),%cl
add    $0x2,%ebx
mov    %cl,0x1(%r15,%rax,1)
movsbl (%r14),%ebp
jmp    1182 <expand+0x52>
movsbl %cl,%ebp
movslq %ebx,%rax
add    $0x1,%ebx
mov    %cl,(%r15,%rax,1)
jmp    1182 <expand+0x52>
mov    %ebp,%edi
call   1050 <isalpha@plt>
test   %rax,%rax
je     1475 <expand+0x345>
mov    $0x1,%r12d
xor    %eax,%eax
mov    (%rsp),%rdi
jmp    1187 <expand+0x57>
and    $0xfffffffffffffffc,%rsi
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbx,1),%rdx
xor    %ecx,%ecx
nop
movdqa %xmm0,%xmm1
paddb  %xmm3,%xmm1
movdqu %xmm0,-0x70(%rdx,%rcx,1)
movdqu %xmm1,-0x60(%rdx,%rcx,1)
movdqa %xmm0,%xmm1
paddb  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm8,%xmm2
movdqu %xmm1,-0x50(%rdx,%rcx,1)
movdqu %xmm2,-0x40(%rdx,%rcx,1)
movdqa %xmm0,%xmm1
paddb  %xmm9,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm10,%xmm2
movdqu %xmm1,-0x30(%rdx,%rcx,1)
movdqu %xmm2,-0x20(%rdx,%rcx,1)
movdqa %xmm0,%xmm1
paddb  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm6,%xmm2
movdqu %xmm1,-0x10(%rdx,%rcx,1)
movdqu %xmm2,(%rdx,%rcx,1)
sub    $0xffffffffffffff80,%rcx
pxor   %xmm7,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    13a0 <expand+0x270>
test   %rbp,%rbp
je     1450 <expand+0x320>
add    %rbx,%rcx
add    0x10(%rsp),%rcx
shl    $0x5,%rbp
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm3,%xmm1
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm1,(%rcx,%rdx,1)
paddb  %xmm4,%xmm0
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    1430 <expand+0x300>
add    %r8,%rbx
cmp    %r8,%r9
je     1170 <expand+0x40>
add    %r8d,%eax
nop
mov    %al,(%r15,%rbx,1)
add    $0x1,%rbx
add    $0x1,%eax
cmp    %eax,%r12d
jne    1460 <expand+0x330>
jmp    1170 <expand+0x40>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x2d,(%r15,%rax,1)
xor    %eax,%eax
xor    %r12d,%r12d
mov    (%rsp),%rdi
jmp    1187 <expand+0x57>
or     %eax,%r12d
je     14a3 <expand+0x373>
cmp    $0x3e6,%ebx
jl     14b2 <expand+0x382>
mov    %ebx,%eax
jmp    14c5 <expand+0x395>
xor    %ebx,%ebx
jmp    14c2 <expand+0x392>
mov    $0x3e7,%eax
cmp    $0x3e8,%ebx
jne    14c2 <expand+0x392>
jmp    14c5 <expand+0x395>
movslq %ebx,%rax
mov    %bpl,(%r15,%rax,1)
add    $0x2,%ebx
movb   $0x2d,0x1(%r15,%rax,1)
movslq %ebx,%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 i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %7
store i32 0, i32* %6
store i32 0, i32* %5
store i32 0, i32* %9
store i32 0, i32* %10
br label %12
12: ; preds = %227, %2
%13 = load i8*, i8** %3
%14 = load i32, i32* %5
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
%17 = load i8, i8* %16
%18 = icmp ne i8 %17, 0
br i1 %18, label %19, label %230
19: ; preds = %12
%20 = load i32, i32* %9
%21 = icmp ne i32 %20, 0
br i1 %21, label %22, label %96
22: ; preds = %19
store i32 0, i32* %9
%23 = load i8*, i8** %3
%24 = load i32, i32* %5
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = call i64 @isdigit(i32 %28)
%30 = icmp ne i64 %29, 0
br i1 %30, label %31, label %64
31: ; preds = %22
%32 = load i32, i32* %11
%33 = load i8*, i8** %3
%34 = load i32, i32* %5
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8, i8* %33, i64 %35
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp slt i32 %32, %38
br i1 %39, label %40, label %64
40: ; preds = %31
%41 = load i32, i32* %11
%42 = add nsw i32 %41, 1
store i32 %42, i32* %7
br label %43
43: ; preds = %60, %40
%44 = load i32, i32* %7
%45 = load i8*, i8** %3
%46 = load i32, i32* %5
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %45, i64 %47
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = icmp sle i32 %44, %50
br i1 %51, label %52, label %63
52: ; preds = %43
%53 = load i32, i32* %7
%54 = trunc i32 %53 to i8
%55 = load i8*, i8** %4
%56 = load i32, i32* %6
%57 = add nsw i32 %56, 1
store i32 %57, i32* %6
%58 = sext i32 %56 to i64
%59 = getelementptr inbounds i8, i8* %55, i64 %58
store i8 %54, i8* %59
br label %60
60: ; preds = %52
%61 = load i32, i32* %7
%62 = add nsw i32 %61, 1
store i32 %62, i32* %7
br label %43
63: ; preds = %43
store i32 -1, i32* %11
br label %95
64: ; preds = %31, %22
%65 = load i32, i32* %6
%66 = add nsw i32 %65, 3
%67 = icmp sge i32 %66, 1000
br i1 %67, label %68, label %73
68: ; preds = %64
%69 = load i8*, i8** %4
%70 = load i32, i32* %6
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
store i8 0, i8* %72
br label %272
73: ; preds = %64
%74 = load i8*, i8** %4
%75 = load i32, i32* %6
%76 = add nsw i32 %75, 1
store i32 %76, i32* %6
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds i8, i8* %74, i64 %77
store i8 45, i8* %78
%79 = load i8*, i8** %3
%80 = load i32, i32* %5
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8, i8* %79, i64 %81
%83 = load i8, i8* %82
%84 = load i8*, i8** %4
%85 = load i32, i32* %6
%86 = add nsw i32 %85, 1
store i32 %86, i32* %6
%87 = sext i32 %85 to i64
%88 = getelementptr inbounds i8, i8* %84, i64 %87
store i8 %83, i8* %88
%89 = load i8*, i8** %3
%90 = load i32, i32* %5
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %89, i64 %91
%93 = load i8, i8* %92
%94 = sext i8 %93 to i32
store i32 %94, i32* %11
br label %95
95: ; preds = %73, %63
br label %227
96: ; preds = %19
%97 = load i32, i32* %10
%98 = icmp ne i32 %97, 0
br i1 %98, label %99, label %182
99: ; preds = %96
store i32 0, i32* %10
%100 = load i32, i32* %11
%101 = trunc i32 %100 to i8
%102 = call i32 @tolower(i8 signext %101)
store i32 %102, i32* %7
%103 = load i8*, i8** %3
%104 = load i32, i32* %5
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
%107 = load i8, i8* %106
%108 = call i32 @tolower(i8 signext %107)
store i32 %108, i32* %8
%109 = load i8*, i8** %3
%110 = load i32, i32* %5
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %109, i64 %111
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = call i64 @isalpha(i32 %114)
%116 = icmp ne i64 %115, 0
br i1 %116, label %117, label %150
117: ; preds = %99
%118 = load i32, i32* %7
%119 = load i32, i32* %8
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %150
121: ; preds = %117
%122 = load i32, i32* %7
%123 = add nsw i32 %122, 1
store i32 %123, i32* %7
br label %124
124: ; preds = %136, %121
%125 = load i32, i32* %7
%126 = load i32, i32* %8
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %139
128: ; preds = %124
%129 = load i32, i32* %7
%130 = trunc i32 %129 to i8
%131 = load i8*, i8** %4
%132 = load i32, i32* %6
%133 = add nsw i32 %132, 1
store i32 %133, i32* %6
%134 = sext i32 %132 to i64
%135 = getelementptr inbounds i8, i8* %131, i64 %134
store i8 %130, i8* %135
br label %136
136: ; preds = %128
%137 = load i32, i32* %7
%138 = add nsw i32 %137, 1
store i32 %138, i32* %7
br label %124
139: ; preds = %124
%140 = load i8*, i8** %3
%141 = load i32, i32* %5
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = load i8*, i8** %4
%146 = load i32, i32* %6
%147 = add nsw i32 %146, 1
store i32 %147, i32* %6
%148 = sext i32 %146 to i64
%149 = getelementptr inbounds i8, i8* %145, i64 %148
store i8 %144, i8* %149
store i32 -1, i32* %11
br label %181
150: ; preds = %117, %99
%151 = load i32, i32* %6
%152 = add nsw i32 %151, 3
%153 = icmp sge i32 %152, 1000
br i1 %153, label %154, label %159
154: ; preds = %150
%155 = load i8*, i8** %4
%156 = load i32, i32* %6
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %155, i64 %157
store i8 0, i8* %158
br label %272
159: ; preds = %150
%160 = load i8*, i8** %4
%161 = load i32, i32* %6
%162 = add nsw i32 %161, 1
store i32 %162, i32* %6
%163 = sext i32 %161 to i64
%164 = getelementptr inbounds i8, i8* %160, i64 %163
store i8 45, i8* %164
%165 = load i8*, i8** %3
%166 = load i32, i32* %5
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i8, i8* %165, i64 %167
%169 = load i8, i8* %168
%170 = load i8*, i8** %4
%171 = load i32, i32* %6
%172 = add nsw i32 %171, 1
store i32 %172, i32* %6
%173 = sext i32 %171 to i64
%174 = getelementptr inbounds i8, i8* %170, i64 %173
store i8 %169, i8* %174
%175 = load i8*, i8** %3
%176 = load i32, i32* %5
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %175, i64 %177
%179 = load i8, i8* %178
%180 = sext i8 %179 to i32
store i32 %180, i32* %11
br label %181
181: ; preds = %159, %139
br label %226
182: ; preds = %96
%183 = load i8*, i8** %3
%184 = load i32, i32* %5
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i8, i8* %183, i64 %185
%187 = load i8, i8* %186
%188 = sext i8 %187 to i32
%189 = icmp eq i32 %188, 45
br i1 %189, label %190, label %208
190: ; preds = %182
%191 = load i32, i32* %11
%192 = call i64 @isdigit(i32 %191)
%193 = icmp ne i64 %192, 0
br i1 %193, label %194, label %195
194: ; preds = %190
store i32 1, i32* %9
br label %207
195: ; preds = %190
%196 = load i32, i32* %11
%197 = call i64 @isalpha(i32 %196)
%198 = icmp ne i64 %197, 0
br i1 %198, label %199, label %200
199: ; preds = %195
store i32 1, i32* %10
br label %206
200: ; preds = %195
%201 = load i8*, i8** %4
%202 = load i32, i32* %6
%203 = add nsw i32 %202, 1
store i32 %203, i32* %6
%204 = sext i32 %202 to i64
%205 = getelementptr inbounds i8, i8* %201, i64 %204
store i8 45, i8* %205
br label %206
206: ; preds = %200, %199
br label %207
207: ; preds = %206, %194
br label %225
208: ; preds = %182
%209 = load i8*, i8** %3
%210 = load i32, i32* %5
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %209, i64 %211
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
store i32 %214, i32* %11
%215 = load i8*, i8** %3
%216 = load i32, i32* %5
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %215, i64 %217
%219 = load i8, i8* %218
%220 = load i8*, i8** %4
%221 = load i32, i32* %6
%222 = add nsw i32 %221, 1
store i32 %222, i32* %6
%223 = sext i32 %221 to i64
%224 = getelementptr inbounds i8, i8* %220, i64 %223
store i8 %219, i8* %224
br label %225
225: ; preds = %208, %207
br label %226
226: ; preds = %225, %181
br label %227
227: ; preds = %226, %95
%228 = load i32, i32* %5
%229 = add nsw i32 %228, 1
store i32 %229, i32* %5
br label %12
230: ; preds = %12
%231 = load i32, i32* %10
%232 = icmp ne i32 %231, 0
br i1 %232, label %236, label %233
233: ; preds = %230
%234 = load i32, i32* %9
%235 = icmp ne i32 %234, 0
br i1 %235, label %236, label %258
236: ; preds = %233, %230
%237 = load i32, i32* %6
%238 = add nsw i32 %237, 2
%239 = icmp sge i32 %238, 1000
br i1 %239, label %240, label %245
240: ; preds = %236
%241 = load i8*, i8** %4
%242 = load i32, i32* %6
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i8, i8* %241, i64 %243
store i8 0, i8* %244
br label %272
245: ; preds = %236
%246 = load i32, i32* %11
%247 = trunc i32 %246 to i8
%248 = load i8*, i8** %4
%249 = load i32, i32* %6
%250 = add nsw i32 %249, 1
store i32 %250, i32* %6
%251 = sext i32 %249 to i64
%252 = getelementptr inbounds i8, i8* %248, i64 %251
store i8 %247, i8* %252
%253 = load i8*, i8** %4
%254 = load i32, i32* %6
%255 = add nsw i32 %254, 1
store i32 %255, i32* %6
%256 = sext i32 %254 to i64
%257 = getelementptr inbounds i8, i8* %253, i64 %256
store i8 45, i8* %257
br label %258
258: ; preds = %245, %233
%259 = load i32, i32* %6
%260 = icmp eq i32 %259, 1000
br i1 %260, label %261, label %267
261: ; preds = %258
%262 = load i8*, i8** %4
%263 = load i32, i32* %6
%264 = sub nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %262, i64 %265
store i8 0, i8* %266
br label %272
267: ; preds = %258
%268 = load i8*, i8** %4
%269 = load i32, i32* %6
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i8, i8* %268, i64 %270
store i8 0, i8* %271
br label %272
272: ; preds = %267, %261, %240, %154, %68
ret void
}

LLVM IR (-O2):
define void @expand(i8* nocapture %0, i8* nocapture writeonly %1) {
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %224, label %5
5: ; preds = %2, %198
%6 = phi i64 [ %203, %198 ], [ 0, %2 ]
%7 = phi i8 [ %205, %198 ], [ %3, %2 ]
%8 = phi i8* [ %204, %198 ], [ %0, %2 ]
%9 = phi i32 [ %202, %198 ], [ undef, %2 ]
%10 = phi i32 [ %201, %198 ], [ 0, %2 ]
%11 = phi i32 [ %200, %198 ], [ 0, %2 ]
%12 = phi i32 [ %199, %198 ], [ 0, %2 ]
%13 = icmp eq i32 %11, 0
br i1 %13, label %48, label %14
14: ; preds = %5
%15 = sext i8 %7 to i32
%16 = tail call i64 @isdigit(i32 %15)
%17 = icmp eq i64 %16, 0
br i1 %17, label %34, label %18
18: ; preds = %14
%19 = load i8, i8* %8
%20 = sext i8 %19 to i32
%21 = icmp slt i32 %9, %20
br i1 %21, label %22, label %34
22: ; preds = %18
%23 = sext i32 %12 to i64
br label %24
24: ; preds = %22, %24
%25 = phi i64 [ %23, %22 ], [ %29, %24 ]
%26 = phi i32 [ %9, %22 ], [ %27, %24 ]
%27 = add nsw i32 %26, 1
%28 = trunc i32 %27 to i8
%29 = add nsw i64 %25, 1
%30 = getelementptr inbounds i8, i8* %1, i64 %25
store i8 %28, i8* %30
%31 = load i8, i8* %8
%32 = sext i8 %31 to i32
%33 = icmp slt i32 %27, %32
br i1 %33, label %24, label %196
34: ; preds = %18, %14
%35 = icmp sgt i32 %12, 996
br i1 %35, label %36, label %38
36: ; preds = %34
%37 = zext i32 %12 to i64
br label %227
38: ; preds = %34
%39 = add nsw i32 %12, 1
%40 = sext i32 %12 to i64
%41 = getelementptr inbounds i8, i8* %1, i64 %40
store i8 45, i8* %41
%42 = load i8, i8* %8
%43 = add nsw i32 %12, 2
%44 = sext i32 %39 to i64
%45 = getelementptr inbounds i8, i8* %1, i64 %44
store i8 %42, i8* %45
%46 = load i8, i8* %8
%47 = sext i8 %46 to i32
br label %198
48: ; preds = %5
%49 = icmp eq i32 %10, 0
br i1 %49, label %179, label %50
50: ; preds = %48
%51 = trunc i32 %9 to i8
%52 = tail call i32 @tolower(i8 signext %51)
%53 = load i8, i8* %8
%54 = tail call i32 @tolower(i8 signext %53)
%55 = load i8, i8* %8
%56 = sext i8 %55 to i32
%57 = tail call i64 @isalpha(i32 %56)
%58 = icmp ne i64 %57, 0
%59 = icmp slt i32 %52, %54
%60 = select i1 %58, i1 %59, i1 false
br i1 %60, label %61, label %165
61: ; preds = %50
%62 = add nsw i32 %52, 1
%63 = icmp slt i32 %62, %54
br i1 %63, label %64, label %159
64: ; preds = %61
%65 = sext i32 %12 to i64
%66 = add i32 %54, -2
%67 = sub i32 %66, %52
%68 = zext i32 %67 to i64
%69 = add nuw nsw i64 %68, 1
%70 = icmp ult i32 %67, 31
br i1 %70, label %145, label %71
71: ; preds = %64
%72 = and i64 %69, 8589934560
%73 = add nsw i64 %72, %65
%74 = trunc i64 %72 to i32
%75 = add i32 %62, %74
%76 = trunc i32 %62 to i8
%77 = insertelement <16 x i8> poison, i8 %76, i64 0
%78 = shufflevector <16 x i8> %77, <16 x i8> poison, <16 x i32> zeroinitializer
%79 = add <16 x i8> %78, <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>
%80 = add nsw i64 %72, -32
%81 = lshr exact i64 %80, 5
%82 = add nuw nsw i64 %81, 1
%83 = and i64 %82, 3
%84 = icmp ult i64 %80, 96
br i1 %84, label %125, label %85
85: ; preds = %71
%86 = and i64 %82, 1152921504606846972
br label %87
87: ; preds = %87, %85
%88 = phi i64 [ 0, %85 ], [ %121, %87 ]
%89 = phi <16 x i8> [ %79, %85 ], [ %122, %87 ]
%90 = phi i64 [ 0, %85 ], [ %123, %87 ]
%91 = add i64 %88, %65
%92 = add <16 x i8> %89, <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>
%93 = getelementptr inbounds i8, i8* %1, i64 %91
%94 = bitcast i8* %93 to <16 x i8>*
store <16 x i8> %89, <16 x i8>* %94
%95 = getelementptr inbounds i8, i8* %93, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
store <16 x i8> %92, <16 x i8>* %96
%97 = or i64 %88, 32
%98 = add <16 x i8> %89, <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>
%99 = add i64 %97, %65
%100 = add <16 x i8> %89, <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>
%101 = getelementptr inbounds i8, i8* %1, i64 %99
%102 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %102
%103 = getelementptr inbounds i8, i8* %101, i64 16
%104 = bitcast i8* %103 to <16 x i8>*
store <16 x i8> %100, <16 x i8>* %104
%105 = or i64 %88, 64
%106 = add <16 x i8> %89, <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>
%107 = add i64 %105, %65
%108 = add <16 x i8> %89, <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>
%109 = getelementptr inbounds i8, i8* %1, i64 %107
%110 = bitcast i8* %109 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %110
%111 = getelementptr inbounds i8, i8* %109, i64 16
%112 = bitcast i8* %111 to <16 x i8>*
store <16 x i8> %108, <16 x i8>* %112
%113 = or i64 %88, 96
%114 = add <16 x i8> %89, <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>
%115 = add i64 %113, %65
%116 = add <16 x i8> %89, <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>
%117 = getelementptr inbounds i8, i8* %1, i64 %115
%118 = bitcast i8* %117 to <16 x i8>*
store <16 x i8> %114, <16 x i8>* %118
%119 = getelementptr inbounds i8, i8* %117, i64 16
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %116, <16 x i8>* %120
%121 = add nuw i64 %88, 128
%122 = xor <16 x i8> %89, <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>
%123 = add i64 %90, 4
%124 = icmp eq i64 %123, %86
br i1 %124, label %125, label %87
125: ; preds = %87, %71
%126 = phi i64 [ 0, %71 ], [ %121, %87 ]
%127 = phi <16 x i8> [ %79, %71 ], [ %122, %87 ]
%128 = icmp eq i64 %83, 0
br i1 %128, label %143, label %129
129: ; preds = %125, %129
%130 = phi i64 [ %139, %129 ], [ %126, %125 ]
%131 = phi <16 x i8> [ %140, %129 ], [ %127, %125 ]
%132 = phi i64 [ %141, %129 ], [ 0, %125 ]
%133 = add i64 %130, %65
%134 = add <16 x i8> %131, <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>
%135 = getelementptr inbounds i8, i8* %1, i64 %133
%136 = bitcast i8* %135 to <16 x i8>*
store <16 x i8> %131, <16 x i8>* %136
%137 = getelementptr inbounds i8, i8* %135, i64 16
%138 = bitcast i8* %137 to <16 x i8>*
store <16 x i8> %134, <16 x i8>* %138
%139 = add nuw i64 %130, 32
%140 = add <16 x i8> %131, <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>
%141 = add i64 %132, 1
%142 = icmp eq i64 %141, %83
br i1 %142, label %143, label %129
143: ; preds = %129, %125
%144 = icmp eq i64 %69, %72
br i1 %144, label %156, label %145
145: ; preds = %64, %143
%146 = phi i64 [ %65, %64 ], [ %73, %143 ]
%147 = phi i32 [ %62, %64 ], [ %75, %143 ]
br label %148
148: ; preds = %145, %148
%149 = phi i64 [ %152, %148 ], [ %146, %145 ]
%150 = phi i32 [ %154, %148 ], [ %147, %145 ]
%151 = trunc i32 %150 to i8
%152 = add nsw i64 %149, 1
%153 = getelementptr inbounds i8, i8* %1, i64 %149
store i8 %151, i8* %153
%154 = add nsw i32 %150, 1
%155 = icmp eq i32 %154, %54
br i1 %155, label %156, label %148
156: ; preds = %148, %143
%157 = phi i64 [ %73, %143 ], [ %152, %148 ]
%158 = trunc i64 %157 to i32
br label %159
159: ; preds = %156, %61
%160 = phi i32 [ %12, %61 ], [ %158, %156 ]
%161 = load i8, i8* %8
%162 = add nsw i32 %160, 1
%163 = sext i32 %160 to i64
%164 = getelementptr inbounds i8, i8* %1, i64 %163
store i8 %161, i8* %164
br label %198
165: ; preds = %50
%166 = icmp sgt i32 %12, 996
br i1 %166, label %167, label %169
167: ; preds = %165
%168 = zext i32 %12 to i64
br label %227
169: ; preds = %165
%170 = add nsw i32 %12, 1
%171 = sext i32 %12 to i64
%172 = getelementptr inbounds i8, i8* %1, i64 %171
store i8 45, i8* %172
%173 = load i8, i8* %8
%174 = add nsw i32 %12, 2
%175 = sext i32 %170 to i64
%176 = getelementptr inbounds i8, i8* %1, i64 %175
store i8 %173, i8* %176
%177 = load i8, i8* %8
%178 = sext i8 %177 to i32
br label %198
179: ; preds = %48
%180 = icmp eq i8 %7, 45
br i1 %180, label %181, label %191
181: ; preds = %179
%182 = tail call i64 @isdigit(i32 %9)
%183 = icmp eq i64 %182, 0
br i1 %183, label %184, label %198
184: ; preds = %181
%185 = tail call i64 @isalpha(i32 %9)
%186 = icmp eq i64 %185, 0
br i1 %186, label %187, label %198
187: ; preds = %184
%188 = add nsw i32 %12, 1
%189 = sext i32 %12 to i64
%190 = getelementptr inbounds i8, i8* %1, i64 %189
store i8 45, i8* %190
br label %198
191: ; preds = %179
%192 = sext i8 %7 to i32
%193 = add nsw i32 %12, 1
%194 = sext i32 %12 to i64
%195 = getelementptr inbounds i8, i8* %1, i64 %194
store i8 %7, i8* %195
br label %198
196: ; preds = %24
%197 = trunc i64 %29 to i32
br label %198
198: ; preds = %196, %184, %181, %169, %159, %187, %191, %38
%199 = phi i32 [ %43, %38 ], [ %162, %159 ], [ %174, %169 ], [ %188, %187 ], [ %193, %191 ], [ %12, %181 ], [ %12, %184 ], [ %197, %196 ]
%200 = phi i32 [ 0, %38 ], [ 0, %159 ], [ 0, %169 ], [ 0, %187 ], [ 0, %191 ], [ 1, %181 ], [ 0, %184 ], [ 0, %196 ]
%201 = phi i32 [ %10, %38 ], [ 0, %159 ], [ 0, %169 ], [ 0, %187 ], [ 0, %191 ], [ 0, %181 ], [ 1, %184 ], [ %10, %196 ]
%202 = phi i32 [ %47, %38 ], [ -1, %159 ], [ %178, %169 ], [ %9, %187 ], [ %192, %191 ], [ %9, %181 ], [ %9, %184 ], [ -1, %196 ]
%203 = add nuw i64 %6, 1
%204 = getelementptr inbounds i8, i8* %0, i64 %203
%205 = load i8, i8* %204
%206 = icmp eq i8 %205, 0
br i1 %206, label %207, label %5
207: ; preds = %198
%208 = or i32 %201, %200
%209 = icmp eq i32 %208, 0
br i1 %209, label %222, label %210
210: ; preds = %207
%211 = icmp sgt i32 %199, 997
br i1 %211, label %212, label %214
212: ; preds = %210
%213 = zext i32 %199 to i64
br label %227
214: ; preds = %210
%215 = trunc i32 %202 to i8
%216 = add nsw i32 %199, 1
%217 = sext i32 %199 to i64
%218 = getelementptr inbounds i8, i8* %1, i64 %217
store i8 %215, i8* %218
%219 = add nsw i32 %199, 2
%220 = sext i32 %216 to i64
%221 = getelementptr inbounds i8, i8* %1, i64 %220
store i8 45, i8* %221
br label %224
222: ; preds = %207
%223 = icmp eq i32 %199, 1000
br i1 %223, label %227, label %224
224: ; preds = %2, %214, %222
%225 = phi i32 [ %219, %214 ], [ %199, %222 ], [ 0, %2 ]
%226 = sext i32 %225 to i64
br label %227
227: ; preds = %222, %224, %212, %167, %36
%228 = phi i64 [ %226, %224 ], [ %213, %212 ], [ %168, %167 ], [ %37, %36 ], [ 999, %222 ]
%229 = getelementptr inbounds i8, i8* %1, i64 %228
store i8 0, i8* %229
ret void
}