#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 strlen(char *);
void expand(char s1[], char s2[]) {
  int i, j, from, to;
  i = j = 0;
  for (i = 0; i <= strlen(s1); i++)
    if (s1[i] == '-') {
      if (i == 0) {
        if (s1[i + 1] == '\0') {
          s2[j++] = s1[i];
          s2[j] = '\0';
          return;
        } else {
          from = s1[i];
          s2[j++] = from;
          to = s1[i + 1];
        }
      } else if ((i + 1) < strlen(s1)) {
        from = s1[i - 1];
        to = s1[i + 1];
      } else {
        from = s1[i - 1];
        to = s1[i];
      }
      if (from < to) {
        from++;
        while (from < to)
          s2[j++] = from++;
      } else {
        from--;
        while (from > to)
          s2[j++] = from--;
      }
      if (to == '-')
        s2[j++] = '-';
    } else {
      s2[j++] = s1[i];
    }
  return;
}


x86 assembly (clang, -O0):
<expand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x24(%rbp),%eax
cmp    %ecx,%eax
jg     1357 <expand+0x247>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1324 <expand+0x214>
cmpl   $0x0,-0x14(%rbp)
jne    11fd <expand+0xed>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    11bb <expand+0xab>
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    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    135c <expand+0x24c>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x1c(%rbp)
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    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x20(%rbp)
jmp    1271 <expand+0x161>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%eax
cmp    %ecx,%eax
jge    1249 <expand+0x139>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x20(%rbp)
jmp    126c <expand+0x15c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x20(%rbp)
jmp    1271 <expand+0x161>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12be <expand+0x1ae>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12b9 <expand+0x1a9>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
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)
jmp    1286 <expand+0x176>
jmp    12ff <expand+0x1ef>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    12fa <expand+0x1ea>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
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)
jmp    12c7 <expand+0x1b7>
jmp    12ff <expand+0x1ef>
cmpl   $0x2d,-0x20(%rbp)
jne    131f <expand+0x20f>
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    1344 <expand+0x234>
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    1349 <expand+0x239>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1135 <expand+0x25>
jmp    135c <expand+0x24c>
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,%r13
mov    %rdi,%r14
call   1030 <strlen@plt>
test   %eax,%eax
js     15d5 <expand+0x4c5>
lea    0x1(%r14),%r15
lea    0x70(%r13),%rax
mov    %rax,0x8(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
movdqa 0xf4d(%rip),%xmm9
movdqa 0xf55(%rip),%xmm4
movdqa 0xf5c(%rip),%xmm8
movdqa 0xf64(%rip),%xmm6
movdqa 0xf6c(%rip),%xmm7
movdqa 0xf74(%rip),%xmm5
movdqa 0xf7c(%rip),%xmm3
xor    %ebp,%ebp
movdqa 0xee1(%rip),%xmm10
jmp    1209 <expand+0xf9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rax
add    $0x1,%ebp
mov    %cl,0x0(%r13,%rax,1)
lea    0x1(%r12),%rbx
mov    %r14,%rdi
call   1030 <strlen@plt>
cltq
cmp    %rax,%r12
mov    %rbx,%r12
movdqa 0xed7(%rip),%xmm9
movdqa 0xedf(%rip),%xmm4
movdqa 0xee6(%rip),%xmm8
movdqa 0xeee(%rip),%xmm6
movdqa 0xef6(%rip),%xmm7
movdqa 0xefe(%rip),%xmm5
movdqa 0xf06(%rip),%xmm3
movdqa 0xe6d(%rip),%xmm10
jge    15d5 <expand+0x4c5>
mov    (%r14,%r12,1),%cl
cmp    $0x2d,%cl
jne    11a0 <expand+0x90>
test   %r12,%r12
je     123c <expand+0x12c>
mov    %r15,%rbx
lea    0x1(%r12),%r15
mov    %r14,%rdi
call   1030 <strlen@plt>
cltq
movsbl -0x1(%r12,%r14,1),%ecx
cmp    %rax,%r15
jge    125d <expand+0x14d>
mov    %r15d,%eax
add    %r14,%rax
jmp    1261 <expand+0x151>
movslq %ebp,%rax
lea    0x1(%rax),%rbp
cmpb   $0x0,(%r15)
movb   $0x2d,0x0(%r13,%rax,1)
je     15cf <expand+0x4bf>
mov    $0x2d,%ecx
mov    %r15,%rax
jmp    12a7 <expand+0x197>
lea    (%r14,%r12,1),%rax
mov    %rbx,%r15
movdqa 0xe33(%rip),%xmm9
movdqa 0xe3b(%rip),%xmm4
movdqa 0xe42(%rip),%xmm8
movdqa 0xe4a(%rip),%xmm6
movdqa 0xe52(%rip),%xmm7
movdqa 0xe5a(%rip),%xmm5
movdqa 0xe62(%rip),%xmm3
movdqa 0xdc9(%rip),%xmm10
movsbl (%rax),%eax
mov    %ecx,%r10d
sub    %eax,%r10d
jge    1330 <expand+0x220>
lea    0x1(%rcx),%edx
cmp    %eax,%edx
jge    15c0 <expand+0x4b0>
movslq %ebp,%rbp
mov    %eax,%r9d
sub    %ecx,%r9d
add    $0xfffffffe,%r9d
cmp    $0x1f,%r9d
jb     14c0 <expand+0x3b0>
add    $0x1,%r9
mov    %r9,%r8
movabs $0x1ffffffe0,%rcx
and    %rcx,%r8
movd   %edx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddb  0xd8e(%rip),%xmm0
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x60,%rcx
jae    13db <expand+0x2cb>
xor    %ecx,%ecx
jmp    1478 <expand+0x368>
nopl   0x0(%rax)
add    $0xffffffff,%ecx
cmp    %eax,%ecx
jle    15c0 <expand+0x4b0>
movslq %ebp,%rbp
add    $0xfffffffe,%r10d
cmp    $0x1f,%r10d
jb     15b0 <expand+0x4a0>
add    $0x1,%r10
mov    %r10,%r8
movabs $0x1ffffffe0,%rdx
and    %rdx,%r8
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddb  0xc86(%rip),%xmm0
lea    -0x20(%r8),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdx
movdqa 0xce3(%rip),%xmm8
movdqa 0xc6b(%rip),%xmm4
movdqa 0xc73(%rip),%xmm5
movdqa 0xc7a(%rip),%xmm9
movdqa 0xc82(%rip),%xmm7
movdqa 0xc8a(%rip),%xmm3
movdqa 0xc92(%rip),%xmm6
jae    14d5 <expand+0x3c5>
xor    %esi,%esi
jmp    1568 <expand+0x458>
movabs $0xffffffffffffffc,%rcx
ff ff 0f
and    %rcx,%rdi
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbp,1),%rsi
xor    %ecx,%ecx
movdqa 0xc84(%rip),%xmm10
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddb  %xmm9,%xmm1
movdqu %xmm0,-0x70(%rsi,%rcx,1)
movdqu %xmm1,-0x60(%rsi,%rcx,1)
movdqa %xmm0,%xmm1
paddb  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm8,%xmm2
movdqu %xmm1,-0x50(%rsi,%rcx,1)
movdqu %xmm2,-0x40(%rsi,%rcx,1)
movdqa %xmm0,%xmm1
paddb  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm7,%xmm2
movdqu %xmm1,-0x30(%rsi,%rcx,1)
movdqu %xmm2,-0x20(%rsi,%rcx,1)
movdqa %xmm0,%xmm1
paddb  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm3,%xmm2
movdqu %xmm1,-0x10(%rsi,%rcx,1)
movdqu %xmm2,(%rsi,%rcx,1)
sub    $0xffffffffffffff80,%rcx
pxor   %xmm10,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1400 <expand+0x2f0>
test   %r10,%r10
je     14b1 <expand+0x3a1>
add    %rbp,%rcx
add    0x10(%rsp),%rcx
shl    $0x5,%r10
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm9,%xmm1
movdqu %xmm0,-0x10(%rcx,%rsi,1)
movdqu %xmm1,(%rcx,%rsi,1)
paddb  %xmm4,%xmm0
add    $0x20,%rsi
cmp    %rsi,%r10
jne    1490 <expand+0x380>
add    %r8,%rbp
cmp    %r8,%r9
je     15c0 <expand+0x4b0>
add    %r8d,%edx
mov    %dl,0x0(%r13,%rbp,1)
add    $0x1,%rbp
add    $0x1,%edx
cmp    %edx,%eax
jne    14c0 <expand+0x3b0>
jmp    15c0 <expand+0x4b0>
movabs $0xffffffffffffffc,%rdx
ff ff 0f
and    %rdx,%rdi
mov    0x8(%rsp),%rdx
add    %rbp,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddb  %xmm4,%xmm1
movdqu %xmm0,-0x70(%rdx,%rsi,1)
movdqu %xmm1,-0x60(%rdx,%rsi,1)
movdqa %xmm0,%xmm1
paddb  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm9,%xmm2
movdqu %xmm1,-0x50(%rdx,%rsi,1)
movdqu %xmm2,-0x40(%rdx,%rsi,1)
movdqa %xmm0,%xmm1
paddb  %xmm7,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm3,%xmm2
movdqu %xmm1,-0x30(%rdx,%rsi,1)
movdqu %xmm2,-0x20(%rdx,%rsi,1)
movdqa %xmm0,%xmm1
paddb  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm10,%xmm2
movdqu %xmm1,-0x10(%rdx,%rsi,1)
movdqu %xmm2,(%rdx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
pxor   %xmm8,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    14f0 <expand+0x3e0>
test   %r9,%r9
je     15a0 <expand+0x490>
add    %rbp,%rsi
add    0x10(%rsp),%rsi
shl    $0x5,%r9
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddb  %xmm4,%xmm1
movdqu %xmm0,-0x10(%rsi,%rdx,1)
movdqu %xmm1,(%rsi,%rdx,1)
paddb  %xmm5,%xmm0
add    $0x20,%rdx
cmp    %rdx,%r9
jne    1580 <expand+0x470>
add    %r8,%rbp
cmp    %r8,%r10
je     15c0 <expand+0x4b0>
sub    %r8d,%ecx
nopl   0x0(%rax,%rax,1)
mov    %cl,0x0(%r13,%rbp,1)
add    $0x1,%rbp
add    $0xffffffff,%ecx
cmp    %eax,%ecx
jg     15b0 <expand+0x4a0>
mov    $0x2d,%cl
cmp    $0x2d,%al
je     11a0 <expand+0x90>
jmp    11ab <expand+0x9b>
movb   $0x0,0x0(%r13,%rbp,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
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %6
store i32 0, i32* %5
store i32 0, i32* %5
br label %9
9: ; preds = %167, %2
%10 = load i32, i32* %5
%11 = load i8*, i8** %3
%12 = call i32 @strlen(i8* %11)
%13 = icmp sle i32 %10, %12
br i1 %13, label %14, label %170
14: ; preds = %9
%15 = load i8*, i8** %3
%16 = load i32, i32* %5
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = sext i8 %19 to i32
%21 = icmp eq i32 %20, 45
br i1 %21, label %22, label %155
22: ; preds = %14
%23 = load i32, i32* %5
%24 = icmp eq i32 %23, 0
br i1 %24, label %25, label %71
25: ; preds = %22
%26 = load i8*, i8** %3
%27 = load i32, i32* %5
%28 = add nsw i32 %27, 1
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %26, i64 %29
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = icmp eq i32 %32, 0
br i1 %33, label %34, label %49
34: ; preds = %25
%35 = load i8*, i8** %3
%36 = load i32, i32* %5
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
%39 = load i8, i8* %38
%40 = load i8*, i8** %4
%41 = load i32, i32* %6
%42 = add nsw i32 %41, 1
store i32 %42, i32* %6
%43 = sext i32 %41 to i64
%44 = getelementptr inbounds i8, i8* %40, i64 %43
store i8 %39, i8* %44
%45 = load i8*, i8** %4
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %45, i64 %47
store i8 0, i8* %48
br label %171
49: ; preds = %25
%50 = load i8*, i8** %3
%51 = load i32, i32* %5
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %50, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
store i32 %55, i32* %7
%56 = load i32, i32* %7
%57 = trunc i32 %56 to i8
%58 = load i8*, i8** %4
%59 = load i32, i32* %6
%60 = add nsw i32 %59, 1
store i32 %60, i32* %6
%61 = sext i32 %59 to i64
%62 = getelementptr inbounds i8, i8* %58, i64 %61
store i8 %57, i8* %62
%63 = load i8*, i8** %3
%64 = load i32, i32* %5
%65 = add nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %63, i64 %66
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
store i32 %69, i32* %8
br label %70
70: ; preds = %49
br label %107
71: ; preds = %22
%72 = load i32, i32* %5
%73 = add nsw i32 %72, 1
%74 = load i8*, i8** %3
%75 = call i32 @strlen(i8* %74)
%76 = icmp slt i32 %73, %75
br i1 %76, label %77, label %92
77: ; preds = %71
%78 = load i8*, i8** %3
%79 = load i32, i32* %5
%80 = sub nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8, i8* %78, i64 %81
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
store i32 %84, i32* %7
%85 = load i8*, i8** %3
%86 = load i32, i32* %5
%87 = add nsw i32 %86, 1
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %85, i64 %88
%90 = load i8, i8* %89
%91 = sext i8 %90 to i32
store i32 %91, i32* %8
br label %106
92: ; preds = %71
%93 = load i8*, i8** %3
%94 = load i32, i32* %5
%95 = sub nsw i32 %94, 1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %93, i64 %96
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
store i32 %99, i32* %7
%100 = load i8*, i8** %3
%101 = load i32, i32* %5
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %100, i64 %102
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
store i32 %105, i32* %8
br label %106
106: ; preds = %92, %77
br label %107
107: ; preds = %106, %70
%108 = load i32, i32* %7
%109 = load i32, i32* %8
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %128
111: ; preds = %107
%112 = load i32, i32* %7
%113 = add nsw i32 %112, 1
store i32 %113, i32* %7
br label %114
114: ; preds = %118, %111
%115 = load i32, i32* %7
%116 = load i32, i32* %8
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %127
118: ; preds = %114
%119 = load i32, i32* %7
%120 = add nsw i32 %119, 1
store i32 %120, i32* %7
%121 = trunc i32 %119 to i8
%122 = load i8*, i8** %4
%123 = load i32, i32* %6
%124 = add nsw i32 %123, 1
store i32 %124, i32* %6
%125 = sext i32 %123 to i64
%126 = getelementptr inbounds i8, i8* %122, i64 %125
store i8 %121, i8* %126
br label %114
127: ; preds = %114
br label %145
128: ; preds = %107
%129 = load i32, i32* %7
%130 = add nsw i32 %129, -1
store i32 %130, i32* %7
br label %131
131: ; preds = %135, %128
%132 = load i32, i32* %7
%133 = load i32, i32* %8
%134 = icmp sgt i32 %132, %133
br i1 %134, label %135, label %144
135: ; preds = %131
%136 = load i32, i32* %7
%137 = add nsw i32 %136, -1
store i32 %137, i32* %7
%138 = trunc i32 %136 to i8
%139 = load i8*, i8** %4
%140 = load i32, i32* %6
%141 = add nsw i32 %140, 1
store i32 %141, i32* %6
%142 = sext i32 %140 to i64
%143 = getelementptr inbounds i8, i8* %139, i64 %142
store i8 %138, i8* %143
br label %131
144: ; preds = %131
br label %145
145: ; preds = %144, %127
%146 = load i32, i32* %8
%147 = icmp eq i32 %146, 45
br i1 %147, label %148, label %154
148: ; preds = %145
%149 = load i8*, i8** %4
%150 = load i32, i32* %6
%151 = add nsw i32 %150, 1
store i32 %151, i32* %6
%152 = sext i32 %150 to i64
%153 = getelementptr inbounds i8, i8* %149, i64 %152
store i8 45, i8* %153
br label %154
154: ; preds = %148, %145
br label %166
155: ; preds = %14
%156 = load i8*, i8** %3
%157 = load i32, i32* %5
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i8, i8* %156, i64 %158
%160 = load i8, i8* %159
%161 = load i8*, i8** %4
%162 = load i32, i32* %6
%163 = add nsw i32 %162, 1
store i32 %163, i32* %6
%164 = sext i32 %162 to i64
%165 = getelementptr inbounds i8, i8* %161, i64 %164
store i8 %160, i8* %165
br label %166
166: ; preds = %155, %154
br label %167
167: ; preds = %166
%168 = load i32, i32* %5
%169 = add nsw i32 %168, 1
store i32 %169, i32* %5
br label %9
170: ; preds = %9
br label %171
171: ; preds = %170, %34
ret void
}

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