#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*/ printf(char *, char, ...);
int strlen(char *);
int digits(char *numbers, long answer) {
  int sum = 0;
  int l = strlen(numbers);
  for (int i = 0; i < l; i++) {
    sum += (numbers[i] - '0');
  }
  if (sum == answer) {
    for (int i = 0; i < l; i++) {
      if (i != l - 1)
        printf("%c+", numbers[i]);
      else
        printf("%c=%ld", numbers[i], answer);
    }
    return 0;
  }
  sum = numbers[0] - '0';
  for (int i = 1; i < l; i++) {
    sum -= (numbers[i] - '0');
  }
  if (sum == answer) {
    for (int i = 0; i < l; i++) {
      if (i != l - 1)
        printf("%c-", numbers[i]);
      else
        printf("%c=%ld", numbers[i], answer);
    }
    return 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<digits>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1179 <digits+0x59>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114a <digits+0x2a>
movslq -0x1c(%rbp),%rax
cmp    -0x18(%rbp),%rax
jne    1209 <digits+0xe9>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11fd <digits+0xdd>
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     11ca <digits+0xaa>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
lea    0xe46(%rip),%rdi
movsbl (%rax,%rcx,1),%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    11ea <digits+0xca>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    -0x18(%rbp),%rdx
lea    0xe24(%rip),%rdi
movsbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    11ef <digits+0xcf>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    118e <digits+0x6e>
movl   $0x0,-0x4(%rbp)
jmp    12e5 <digits+0x1c5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    124e <digits+0x12e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x30,%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    121d <digits+0xfd>
movslq -0x1c(%rbp),%rax
cmp    -0x18(%rbp),%rax
jne    12de <digits+0x1be>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12d2 <digits+0x1b2>
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     129f <digits+0x17f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
lea    0xd7c(%rip),%rdi
movsbl (%rax,%rcx,1),%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12bf <digits+0x19f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    -0x18(%rbp),%rdx
lea    0xd4f(%rip),%rdi
movsbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12c4 <digits+0x1a4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1263 <digits+0x143>
movl   $0x0,-0x4(%rbp)
jmp    12e5 <digits+0x1c5>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<digits>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbp
mov    %rdi,%rbx
call   1030 <strlen@plt>
test   %eax,%eax
jle    114e <digits+0x2e>
mov    %eax,%r15d
mov    %eax,%r12d
cmp    $0x8,%eax
jae    116a <digits+0x4a>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    1290 <digits+0x170>
test   %rbp,%rbp
je     14c4 <digits+0x3a4>
movsbq (%rbx),%rax
add    $0xffffffffffffffd0,%rax
cmp    %rbp,%rax
setne  %al
jmp    14c6 <digits+0x3a6>
mov    %r12d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     14d8 <digits+0x3b8>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm0,%xmm0
xor    %edx,%edx
movdqa 0xe73(%rip),%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   (%rbx,%rdx,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%rbx,%rdx,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x18,%xmm3
paddd  %xmm0,%xmm3
psrad  $0x18,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rbx,%rdx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
movd   0xc(%rbx,%rdx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
paddd  %xmm2,%xmm0
paddd  %xmm3,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    11b0 <digits+0x90>
movdqa 0xddb(%rip),%xmm3
movdqa %xmm0,%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm1,%xmm3
test   $0x1,%cl
je     126b <digits+0x14b>
movd   (%rbx,%rdx,1),%xmm0
movd   0x4(%rbx,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
paddd  %xmm0,%xmm2
punpcklbw %xmm1,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
paddd  %xmm0,%xmm3
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
cmp    %r12,%rax
je     12a2 <digits+0x182>
nopw   0x0(%rax,%rax,1)
movsbl (%rbx,%rax,1),%edx
add    %edx,%ecx
add    $0xffffffd0,%ecx
add    $0x1,%rax
cmp    %rax,%r12
jne    1290 <digits+0x170>
movslq %ecx,%rax
cmp    %rbp,%rax
jne    1309 <digits+0x1e9>
test   %r15d,%r15d
jle    14c4 <digits+0x3a4>
add    $0xffffffff,%r15d
lea    0xd82(%rip),%r13
xor    %r14d,%r14d
jmp    12f3 <digits+0x1d3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl (%rbx,%r15,1),%esi
lea    0xd68(%rip),%rdi
mov    %rbp,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r14
cmp    %r14,%r12
je     14c4 <digits+0x3a4>
cmp    %r14,%r15
je     12d0 <digits+0x1b0>
movsbl (%rbx,%r14,1),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    12e6 <digits+0x1c6>
movsbl (%rbx),%edx
add    $0xffffffd0,%edx
cmp    $0x2,%r15d
jl     1462 <digits+0x342>
lea    -0x1(%r12),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     1450 <digits+0x330>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
movd   %edx,%xmm0
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     14f4 <digits+0x3d4>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm1,%xmm1
mov    $0x1,%esi
movdqa 0xcc8(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movd   (%rbx,%rsi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%rbx,%rsi,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x18,%xmm3
psrad  $0x18,%xmm4
movd   0x8(%rbx,%rsi,1),%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
movd   0xc(%rbx,%rsi,1),%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
psrad  $0x18,%xmm5
paddd  %xmm3,%xmm5
psubd  %xmm5,%xmm0
psrad  $0x18,%xmm6
paddd  %xmm4,%xmm6
psubd  %xmm6,%xmm1
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1370 <digits+0x250>
movdqa 0xc3b(%rip),%xmm2
paddd  %xmm1,%xmm2
test   $0x1,%dl
je     1427 <digits+0x307>
movd   (%rbx,%rsi,1),%xmm1
movd   0x4(%rbx,%rsi,1),%xmm3
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
psubd  %xmm1,%xmm0
punpcklbw %xmm3,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
psubd  %xmm1,%xmm2
paddd  0xbfd(%rip),%xmm0
movdqa %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     1462 <digits+0x342>
or     $0x1,%rax
nopw   0x0(%rax,%rax,1)
movsbl (%rbx,%rax,1),%ecx
sub    %ecx,%edx
add    $0x30,%edx
add    $0x1,%rax
cmp    %rax,%r12
jne    1450 <digits+0x330>
movslq %edx,%rax
cmp    %rbp,%rax
setne  %al
jne    14c6 <digits+0x3a6>
test   %r15d,%r15d
jle    14c6 <digits+0x3a6>
mov    %rbp,%r14
add    $0xffffffff,%r15d
lea    0xbcb(%rip),%r13
xor    %ebp,%ebp
jmp    14af <digits+0x38f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl (%rbx,%r15,1),%esi
lea    0xba8(%rip),%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
je     14c4 <digits+0x3a4>
cmp    %rbp,%r15
je     1490 <digits+0x370>
movsbl (%rbx,%rbp,1),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    14a6 <digits+0x386>
xor    %eax,%eax
movzbl %al,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0xb20(%rip),%xmm2
xor    %edx,%edx
movdqa %xmm2,%xmm3
test   $0x1,%cl
jne    1236 <digits+0x116>
jmp    126b <digits+0x14b>
movdqa 0xb24(%rip),%xmm2
mov    $0x1,%esi
test   $0x1,%dl
jne    13ee <digits+0x2ce>
jmp    1427 <digits+0x307>

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

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