#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 *, int);
scalar_t__ scanf(char *, int *, int *, ...);
int main(void) {
  int A, B, C, a, d, t, T = 0;
  int parked[100] = {0};
  if (scanf("%d %d %d", &A, &B, &C) == 0)
    return 1;
  for (int i = 1; i <= 3; i++) {
    if (scanf("%d %d", &a, &d) == 0)
      return 1;
    for (int j = a - 1; j < d - 1; j++) {
      parked[j]++;
    }
  }
  for (int i = 0; i < 100; i++) {
    t = parked[i];
    if (t == 1) {
      T += A;
    } else if (t == 2) {
      T += (2 * B);
    } else if (t == 3) {
      T += (3 * C);
    }
  }
  printf("%d\n", T);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x20(%rbp)
lea    -0x1b0(%rbp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
lea    0xe9d(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
lea    -0x10(%rbp),%rcx
mov    $0x0,%al
call   1050 <scanf@plt>
cmp    $0x0,%rax
jne    118c <main+0x5c>
movl   $0x1,-0x4(%rbp)
jmp    12d5 <main+0x1a5>
movl   $0x1,-0x1b4(%rbp)
cmpl   $0x3,-0x1b4(%rbp)
jg     1234 <main+0x104>
lea    0xe59(%rip),%rdi
lea    -0x14(%rbp),%rsi
lea    -0x18(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
cmp    $0x0,%rax
jne    11cf <main+0x9f>
movl   $0x1,-0x4(%rbp)
jmp    12d5 <main+0x1a5>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    121b <main+0xeb>
movslq -0x1b8(%rbp),%rax
mov    -0x1b0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1b0(%rbp,%rax,4)
mov    -0x1b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1b8(%rbp)
jmp    11db <main+0xab>
jmp    1220 <main+0xf0>
mov    -0x1b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1b4(%rbp)
jmp    1196 <main+0x66>
movl   $0x0,-0x1bc(%rbp)
cmpl   $0x64,-0x1bc(%rbp)
jge    12c6 <main+0x196>
movslq -0x1bc(%rbp),%rax
mov    -0x1b0(%rbp,%rax,4),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jne    1274 <main+0x144>
mov    -0x8(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    12ad <main+0x17d>
cmpl   $0x2,-0x1c(%rbp)
jne    128f <main+0x15f>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    12a8 <main+0x178>
cmpl   $0x3,-0x1c(%rbp)
jne    12a3 <main+0x173>
imul   $0x3,-0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    12a8 <main+0x178>
jmp    12ad <main+0x17d>
jmp    12b2 <main+0x182>
mov    -0x1bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1bc(%rbp)
jmp    123e <main+0x10e>
mov    -0x20(%rbp),%esi
lea    0xd39(%rip),%rdi
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x1b0,%rsp
lea    0x20(%rsp),%rdi
mov    $0x190,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xead(%rip),%rdi
lea    0x1c(%rsp),%rsi
lea    0x18(%rsp),%rdx
lea    0x14(%rsp),%rcx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    $0x1,%r14d
test   %rax,%rax
je     1593 <main+0x463>
lea    0xe84(%rip),%rdi
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
test   %rax,%rax
je     1593 <main+0x463>
mov    0x10(%rsp),%esi
mov    0xc(%rsp),%eax
cmp    %eax,%esi
jge    128d <main+0x15d>
add    $0xffffffff,%eax
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
cmp    %eax,%esi
cmovg  %esi,%eax
mov    %eax,%edx
sub    %esi,%edx
cmp    $0x7,%edx
jb     1280 <main+0x150>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     148a <main+0x35a>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rsp,%rcx,4),%rbp
add    $0x50,%rbp
xor    %edi,%edi
pcmpeqd %xmm0,%xmm0
nopl   0x0(%rax)
movdqu -0x30(%rbp,%rdi,4),%xmm1
movdqu -0x20(%rbp,%rdi,4),%xmm2
movdqu -0x10(%rbp,%rdi,4),%xmm3
movdqu 0x0(%rbp,%rdi,4),%xmm4
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%rbp,%rdi,4)
movdqu %xmm2,-0x20(%rbp,%rdi,4)
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm4
movdqu %xmm3,-0x10(%rbp,%rdi,4)
movdqu %xmm4,0x0(%rbp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1200 <main+0xd0>
test   $0x1,%bl
je     1276 <main+0x146>
add    %rcx,%rdi
movdqu 0x20(%rsp,%rdi,4),%xmm0
movdqu 0x30(%rsp,%rdi,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,0x20(%rsp,%rdi,4)
movdqu %xmm1,0x30(%rsp,%rdi,4)
cmp    %r8,%rdx
je     128d <main+0x15d>
add    %r8,%rcx
xchg   %ax,%ax
addl   $0x1,0x20(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1280 <main+0x150>
lea    0xd6f(%rip),%rdi
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
test   %rax,%rax
je     1593 <main+0x463>
mov    0x10(%rsp),%esi
mov    0xc(%rsp),%eax
cmp    %eax,%esi
jge    13ad <main+0x27d>
add    $0xffffffff,%eax
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
cmp    %eax,%esi
cmovg  %esi,%eax
mov    %eax,%edx
sub    %esi,%edx
cmp    $0x7,%edx
jb     13a0 <main+0x270>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     149a <main+0x36a>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rsp,%rcx,4),%rbp
add    $0x50,%rbp
xor    %edi,%edi
pcmpeqd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rbp,%rdi,4),%xmm1
movdqu -0x20(%rbp,%rdi,4),%xmm2
movdqu -0x10(%rbp,%rdi,4),%xmm3
movdqu 0x0(%rbp,%rdi,4),%xmm4
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%rbp,%rdi,4)
movdqu %xmm2,-0x20(%rbp,%rdi,4)
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm4
movdqu %xmm3,-0x10(%rbp,%rdi,4)
movdqu %xmm4,0x0(%rbp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1320 <main+0x1f0>
test   $0x1,%bl
je     1396 <main+0x266>
add    %rcx,%rdi
movdqu 0x20(%rsp,%rdi,4),%xmm0
movdqu 0x30(%rsp,%rdi,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,0x20(%rsp,%rdi,4)
movdqu %xmm1,0x30(%rsp,%rdi,4)
cmp    %r8,%rdx
je     13ad <main+0x27d>
add    %r8,%rcx
xchg   %ax,%ax
addl   $0x1,0x20(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    13a0 <main+0x270>
lea    0xc4f(%rip),%rdi
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
test   %rax,%rax
je     1593 <main+0x463>
mov    0x10(%rsp),%esi
mov    0xc(%rsp),%eax
cmp    %eax,%esi
jge    14fd <main+0x3cd>
add    $0xffffffff,%eax
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
cmp    %eax,%esi
cmovg  %esi,%eax
mov    %eax,%edx
sub    %esi,%edx
cmp    $0x7,%edx
jb     14f0 <main+0x3c0>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     14aa <main+0x37a>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rsp,%rcx,4),%rsi
add    $0x50,%rsi
xor    %edi,%edi
pcmpeqd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rdi,4),%xmm1
movdqu -0x20(%rsi,%rdi,4),%xmm2
movdqu -0x10(%rsi,%rdi,4),%xmm3
movdqu (%rsi,%rdi,4),%xmm4
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%rsi,%rdi,4)
movdqu %xmm2,-0x20(%rsi,%rdi,4)
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm4
movdqu %xmm3,-0x10(%rsi,%rdi,4)
movdqu %xmm4,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1440 <main+0x310>
jmp    14ac <main+0x37c>
xor    %edi,%edi
test   $0x1,%bl
jne    124f <main+0x11f>
jmp    1276 <main+0x146>
xor    %edi,%edi
test   $0x1,%bl
jne    136f <main+0x23f>
jmp    1396 <main+0x266>
xor    %edi,%edi
test   $0x1,%bpl
je     14d9 <main+0x3a9>
add    %rcx,%rdi
movdqu 0x20(%rsp,%rdi,4),%xmm0
movdqu 0x30(%rsp,%rdi,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,0x20(%rsp,%rdi,4)
movdqu %xmm1,0x30(%rsp,%rdi,4)
cmp    %r8,%rdx
je     14fd <main+0x3cd>
add    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addl   $0x1,0x20(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    14f0 <main+0x3c0>
mov    0x14(%rsp),%eax
lea    (%rax,%rax,2),%eax
mov    0x18(%rsp),%ecx
add    %ecx,%ecx
xor    %esi,%esi
mov    $0x1,%edx
mov    0x1c(%rsp),%edi
jmp    152c <main+0x3fc>
nopw   0x0(%rax,%rax,1)
add    %edi,%esi
add    $0x2,%rdx
cmp    $0x65,%rdx
je     1584 <main+0x454>
mov    0x1c(%rsp,%rdx,4),%ebp
cmp    $0x3,%ebp
je     1550 <main+0x420>
cmp    $0x2,%ebp
je     1560 <main+0x430>
cmp    $0x1,%ebp
jne    1562 <main+0x432>
add    %edi,%esi
jmp    1562 <main+0x432>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %eax,%esi
jmp    1562 <main+0x432>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %ecx,%esi
mov    0x20(%rsp,%rdx,4),%ebp
cmp    $0x1,%ebp
je     1520 <main+0x3f0>
cmp    $0x2,%ebp
je     1580 <main+0x450>
cmp    $0x3,%ebp
jne    1522 <main+0x3f2>
add    %eax,%esi
jmp    1522 <main+0x3f2>
nopl   0x0(%rax)
add    %ecx,%esi
jmp    1522 <main+0x3f2>
lea    0xa7e(%rip),%rdi
call   1030 <printf@plt>
xor    %r14d,%r14d
mov    %r14d,%eax
add    $0x1b0,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
@.str = [9 x i8] c"%d %d %d\00"
@.str.1 = [6 x i8] c"%d %d\00"
@.str.2 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [100 x i32]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %8
%13 = bitcast [100 x i32]* %9 to i8*
%14 = call i64 (i8*, i32*, i32*, ...) @scanf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32* %2, i32* %3, i32* %4)
%15 = icmp eq i64 %14, 0
br i1 %15, label %16, label %17
16: ; preds = %0
store i32 1, i32* %1
br label %86
17: ; preds = %0
store i32 1, i32* %10
br label %18
18: ; preds = %43, %17
%19 = load i32, i32* %10
%20 = icmp sle i32 %19, 3
br i1 %20, label %21, label %46
21: ; preds = %18
%22 = call i64 (i8*, i32*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32* %5, i32* %6)
%23 = icmp eq i64 %22, 0
br i1 %23, label %24, label %25
24: ; preds = %21
store i32 1, i32* %1
br label %86
25: ; preds = %21
%26 = load i32, i32* %5
%27 = sub nsw i32 %26, 1
store i32 %27, i32* %11
br label %28
28: ; preds = %39, %25
%29 = load i32, i32* %11
%30 = load i32, i32* %6
%31 = sub nsw i32 %30, 1
%32 = icmp slt i32 %29, %31
br i1 %32, label %33, label %42
33: ; preds = %28
%34 = load i32, i32* %11
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [100 x i32], [100 x i32]* %9, i64 0, i64 %35
%37 = load i32, i32* %36
%38 = add nsw i32 %37, 1
store i32 %38, i32* %36
br label %39
39: ; preds = %33
%40 = load i32, i32* %11
%41 = add nsw i32 %40, 1
store i32 %41, i32* %11
br label %28
42: ; preds = %28
br label %43
43: ; preds = %42
%44 = load i32, i32* %10
%45 = add nsw i32 %44, 1
store i32 %45, i32* %10
br label %18
46: ; preds = %18
store i32 0, i32* %12
br label %47
47: ; preds = %80, %46
%48 = load i32, i32* %12
%49 = icmp slt i32 %48, 100
br i1 %49, label %50, label %83
50: ; preds = %47
%51 = load i32, i32* %12
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [100 x i32], [100 x i32]* %9, i64 0, i64 %52
%54 = load i32, i32* %53
store i32 %54, i32* %7
%55 = load i32, i32* %7
%56 = icmp eq i32 %55, 1
br i1 %56, label %57, label %61
57: ; preds = %50
%58 = load i32, i32* %2
%59 = load i32, i32* %8
%60 = add nsw i32 %59, %58
store i32 %60, i32* %8
br label %79
61: ; preds = %50
%62 = load i32, i32* %7
%63 = icmp eq i32 %62, 2
br i1 %63, label %64, label %69
64: ; preds = %61
%65 = load i32, i32* %3
%66 = mul nsw i32 2, %65
%67 = load i32, i32* %8
%68 = add nsw i32 %67, %66
store i32 %68, i32* %8
br label %78
69: ; preds = %61
%70 = load i32, i32* %7
%71 = icmp eq i32 %70, 3
br i1 %71, label %72, label %77
72: ; preds = %69
%73 = load i32, i32* %4
%74 = mul nsw i32 3, %73
%75 = load i32, i32* %8
%76 = add nsw i32 %75, %74
store i32 %76, i32* %8
br label %77
77: ; preds = %72, %69
br label %78
78: ; preds = %77, %64
br label %79
79: ; preds = %78, %57
br label %80
80: ; preds = %79
%81 = load i32, i32* %12
%82 = add nsw i32 %81, 1
store i32 %82, i32* %12
br label %47
83: ; preds = %47
%84 = load i32, i32* %8
%85 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %84)
br label %86
86: ; preds = %83, %24, %16
%87 = load i32, i32* %1
ret i32 %87
}

LLVM IR (-O2):
@.str = [9 x i8] c"%d %d %d\00"
@.str.1 = [6 x i8] c"%d %d\00"
@.str.2 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [100 x i32]
%7 = bitcast i32* %1 to i8*
%8 = bitcast i32* %2 to i8*
%9 = bitcast i32* %3 to i8*
%10 = bitcast i32* %4 to i8*
%11 = bitcast i32* %5 to i8*
%12 = bitcast [100 x i32]* %6 to i8*
%13 = call i64 (i8*, i32*, i32*, ...) @scanf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2, i32* %3)
%14 = icmp eq i64 %13, 0
br i1 %14, label %295, label %15
15: ; preds = %0
%16 = call i64 (i8*, i32*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32* %4, i32* %5)
%17 = icmp eq i64 %16, 0
br i1 %17, label %295, label %18
18: ; preds = %15
%19 = load i32, i32* %4
%20 = load i32, i32* %5
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %89
22: ; preds = %18
%23 = add nsw i32 %20, -1
%24 = add i32 %19, -1
%25 = sext i32 %24 to i64
%26 = call i32 @llvm.smax.i32(i32 %19, i32 %23)
%27 = sub i32 %26, %19
%28 = zext i32 %27 to i64
%29 = add nuw nsw i64 %28, 1
%30 = icmp ult i32 %27, 7
br i1 %30, label %87, label %31
31: ; preds = %22
%32 = and i64 %29, 8589934584
%33 = add nsw i64 %32, %25
%34 = add nsw i64 %32, -8
%35 = lshr exact i64 %34, 3
%36 = add nuw nsw i64 %35, 1
%37 = and i64 %36, 1
%38 = icmp eq i64 %34, 0
br i1 %38, label %70, label %39
39: ; preds = %31
%40 = and i64 %36, 4611686018427387902
br label %41
41: ; preds = %41, %39
%42 = phi i64 [ 0, %39 ], [ %67, %41 ]
%43 = phi i64 [ 0, %39 ], [ %68, %41 ]
%44 = add i64 %42, %25
%45 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %44
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = getelementptr inbounds i32, i32* %45, i64 4
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = add nsw <4 x i32> %47, <i32 1, i32 1, i32 1, i32 1>
%52 = add nsw <4 x i32> %50, <i32 1, i32 1, i32 1, i32 1>
%53 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %53
%54 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %54
%55 = or i64 %42, 8
%56 = add i64 %55, %25
%57 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = add nsw <4 x i32> %59, <i32 1, i32 1, i32 1, i32 1>
%64 = add nsw <4 x i32> %62, <i32 1, i32 1, i32 1, i32 1>
%65 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %65
%66 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %66
%67 = add nuw i64 %42, 16
%68 = add i64 %43, 2
%69 = icmp eq i64 %68, %40
br i1 %69, label %70, label %41
70: ; preds = %41, %31
%71 = phi i64 [ 0, %31 ], [ %67, %41 ]
%72 = icmp eq i64 %37, 0
br i1 %72, label %85, label %73
73: ; preds = %70
%74 = add i64 %71, %25
%75 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %74
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = getelementptr inbounds i32, i32* %75, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = add nsw <4 x i32> %77, <i32 1, i32 1, i32 1, i32 1>
%82 = add nsw <4 x i32> %80, <i32 1, i32 1, i32 1, i32 1>
%83 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %83
%84 = bitcast i32* %78 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %84
br label %85
85: ; preds = %70, %73
%86 = icmp eq i64 %29, %32
br i1 %86, label %89, label %87
87: ; preds = %22, %85
%88 = phi i64 [ %25, %22 ], [ %33, %85 ]
br label %259
89: ; preds = %259, %85, %18
%90 = call i64 (i8*, i32*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32* %4, i32* %5)
%91 = icmp eq i64 %90, 0
br i1 %91, label %295, label %92
92: ; preds = %89
%93 = load i32, i32* %4
%94 = load i32, i32* %5
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %171
96: ; preds = %92
%97 = add nsw i32 %94, -1
%98 = add i32 %93, -1
%99 = sext i32 %98 to i64
%100 = call i32 @llvm.smax.i32(i32 %93, i32 %97)
%101 = sub i32 %100, %93
%102 = zext i32 %101 to i64
%103 = add nuw nsw i64 %102, 1
%104 = icmp ult i32 %101, 7
br i1 %104, label %161, label %105
105: ; preds = %96
%106 = and i64 %103, 8589934584
%107 = add nsw i64 %106, %99
%108 = add nsw i64 %106, -8
%109 = lshr exact i64 %108, 3
%110 = add nuw nsw i64 %109, 1
%111 = and i64 %110, 1
%112 = icmp eq i64 %108, 0
br i1 %112, label %144, label %113
113: ; preds = %105
%114 = and i64 %110, 4611686018427387902
br label %115
115: ; preds = %115, %113
%116 = phi i64 [ 0, %113 ], [ %141, %115 ]
%117 = phi i64 [ 0, %113 ], [ %142, %115 ]
%118 = add i64 %116, %99
%119 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %118
%120 = bitcast i32* %119 to <4 x i32>*
%121 = load <4 x i32>, <4 x i32>* %120
%122 = getelementptr inbounds i32, i32* %119, i64 4
%123 = bitcast i32* %122 to <4 x i32>*
%124 = load <4 x i32>, <4 x i32>* %123
%125 = add nsw <4 x i32> %121, <i32 1, i32 1, i32 1, i32 1>
%126 = add nsw <4 x i32> %124, <i32 1, i32 1, i32 1, i32 1>
%127 = bitcast i32* %119 to <4 x i32>*
store <4 x i32> %125, <4 x i32>* %127
%128 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> %126, <4 x i32>* %128
%129 = or i64 %116, 8
%130 = add i64 %129, %99
%131 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %130
%132 = bitcast i32* %131 to <4 x i32>*
%133 = load <4 x i32>, <4 x i32>* %132
%134 = getelementptr inbounds i32, i32* %131, i64 4
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = add nsw <4 x i32> %133, <i32 1, i32 1, i32 1, i32 1>
%138 = add nsw <4 x i32> %136, <i32 1, i32 1, i32 1, i32 1>
%139 = bitcast i32* %131 to <4 x i32>*
store <4 x i32> %137, <4 x i32>* %139
%140 = bitcast i32* %134 to <4 x i32>*
store <4 x i32> %138, <4 x i32>* %140
%141 = add nuw i64 %116, 16
%142 = add i64 %117, 2
%143 = icmp eq i64 %142, %114
br i1 %143, label %144, label %115
144: ; preds = %115, %105
%145 = phi i64 [ 0, %105 ], [ %141, %115 ]
%146 = icmp eq i64 %111, 0
br i1 %146, label %159, label %147
147: ; preds = %144
%148 = add i64 %145, %99
%149 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %148
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = getelementptr inbounds i32, i32* %149, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
%154 = load <4 x i32>, <4 x i32>* %153
%155 = add nsw <4 x i32> %151, <i32 1, i32 1, i32 1, i32 1>
%156 = add nsw <4 x i32> %154, <i32 1, i32 1, i32 1, i32 1>
%157 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %155, <4 x i32>* %157
%158 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> %156, <4 x i32>* %158
br label %159
159: ; preds = %144, %147
%160 = icmp eq i64 %103, %106
br i1 %160, label %171, label %161
161: ; preds = %96, %159
%162 = phi i64 [ %99, %96 ], [ %107, %159 ]
br label %163
163: ; preds = %161, %163
%164 = phi i64 [ %168, %163 ], [ %162, %161 ]
%165 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %164
%166 = load i32, i32* %165
%167 = add nsw i32 %166, 1
store i32 %167, i32* %165
%168 = add nsw i64 %164, 1
%169 = trunc i64 %168 to i32
%170 = icmp eq i32 %100, %169
br i1 %170, label %171, label %163
171: ; preds = %163, %159, %92
%172 = call i64 (i8*, i32*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32* %4, i32* %5)
%173 = icmp eq i64 %172, 0
br i1 %173, label %295, label %174
174: ; preds = %171
%175 = load i32, i32* %4
%176 = load i32, i32* %5
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %253
178: ; preds = %174
%179 = add nsw i32 %176, -1
%180 = add i32 %175, -1
%181 = sext i32 %180 to i64
%182 = call i32 @llvm.smax.i32(i32 %175, i32 %179)
%183 = sub i32 %182, %175
%184 = zext i32 %183 to i64
%185 = add nuw nsw i64 %184, 1
%186 = icmp ult i32 %183, 7
br i1 %186, label %243, label %187
187: ; preds = %178
%188 = and i64 %185, 8589934584
%189 = add nsw i64 %188, %181
%190 = add nsw i64 %188, -8
%191 = lshr exact i64 %190, 3
%192 = add nuw nsw i64 %191, 1
%193 = and i64 %192, 1
%194 = icmp eq i64 %190, 0
br i1 %194, label %226, label %195
195: ; preds = %187
%196 = and i64 %192, 4611686018427387902
br label %197
197: ; preds = %197, %195
%198 = phi i64 [ 0, %195 ], [ %223, %197 ]
%199 = phi i64 [ 0, %195 ], [ %224, %197 ]
%200 = add i64 %198, %181
%201 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %200
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr inbounds i32, i32* %201, i64 4
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = add nsw <4 x i32> %203, <i32 1, i32 1, i32 1, i32 1>
%208 = add nsw <4 x i32> %206, <i32 1, i32 1, i32 1, i32 1>
%209 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %207, <4 x i32>* %209
%210 = bitcast i32* %204 to <4 x i32>*
store <4 x i32> %208, <4 x i32>* %210
%211 = or i64 %198, 8
%212 = add i64 %211, %181
%213 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %212
%214 = bitcast i32* %213 to <4 x i32>*
%215 = load <4 x i32>, <4 x i32>* %214
%216 = getelementptr inbounds i32, i32* %213, i64 4
%217 = bitcast i32* %216 to <4 x i32>*
%218 = load <4 x i32>, <4 x i32>* %217
%219 = add nsw <4 x i32> %215, <i32 1, i32 1, i32 1, i32 1>
%220 = add nsw <4 x i32> %218, <i32 1, i32 1, i32 1, i32 1>
%221 = bitcast i32* %213 to <4 x i32>*
store <4 x i32> %219, <4 x i32>* %221
%222 = bitcast i32* %216 to <4 x i32>*
store <4 x i32> %220, <4 x i32>* %222
%223 = add nuw i64 %198, 16
%224 = add i64 %199, 2
%225 = icmp eq i64 %224, %196
br i1 %225, label %226, label %197
226: ; preds = %197, %187
%227 = phi i64 [ 0, %187 ], [ %223, %197 ]
%228 = icmp eq i64 %193, 0
br i1 %228, label %241, label %229
229: ; preds = %226
%230 = add i64 %227, %181
%231 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %230
%232 = bitcast i32* %231 to <4 x i32>*
%233 = load <4 x i32>, <4 x i32>* %232
%234 = getelementptr inbounds i32, i32* %231, i64 4
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = add nsw <4 x i32> %233, <i32 1, i32 1, i32 1, i32 1>
%238 = add nsw <4 x i32> %236, <i32 1, i32 1, i32 1, i32 1>
%239 = bitcast i32* %231 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %239
%240 = bitcast i32* %234 to <4 x i32>*
store <4 x i32> %238, <4 x i32>* %240
br label %241
241: ; preds = %226, %229
%242 = icmp eq i64 %185, %188
br i1 %242, label %253, label %243
243: ; preds = %178, %241
%244 = phi i64 [ %181, %178 ], [ %189, %241 ]
br label %245
245: ; preds = %243, %245
%246 = phi i64 [ %250, %245 ], [ %244, %243 ]
%247 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %246
%248 = load i32, i32* %247
%249 = add nsw i32 %248, 1
store i32 %249, i32* %247
%250 = add nsw i64 %246, 1
%251 = trunc i64 %250 to i32
%252 = icmp eq i32 %182, %251
br i1 %252, label %253, label %245
253: ; preds = %245, %241, %174
%254 = load i32, i32* %3
%255 = mul nsw i32 %254, 3
%256 = load i32, i32* %2
%257 = shl nsw i32 %256, 1
%258 = load i32, i32* %1
br label %269
259: ; preds = %87, %259
%260 = phi i64 [ %264, %259 ], [ %88, %87 ]
%261 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %260
%262 = load i32, i32* %261
%263 = add nsw i32 %262, 1
store i32 %263, i32* %261
%264 = add nsw i64 %260, 1
%265 = trunc i64 %264 to i32
%266 = icmp eq i32 %26, %265
br i1 %266, label %89, label %259
267: ; preds = %291
%268 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %292)
br label %295
269: ; preds = %291, %253
%270 = phi i64 [ 0, %253 ], [ %293, %291 ]
%271 = phi i32 [ 0, %253 ], [ %292, %291 ]
%272 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %270
%273 = load i32, i32* %272
switch i32 %273, label %280 [
i32 1, label %274
i32 2, label %276
i32 3, label %278
]
274: ; preds = %269
%275 = add nsw i32 %258, %271
br label %280
276: ; preds = %269
%277 = add nsw i32 %257, %271
br label %280
278: ; preds = %269
%279 = add nsw i32 %255, %271
br label %280
280: ; preds = %269, %274, %278, %276
%281 = phi i32 [ %275, %274 ], [ %277, %276 ], [ %279, %278 ], [ %271, %269 ]
%282 = or i64 %270, 1
%283 = getelementptr inbounds [100 x i32], [100 x i32]* %6, i64 0, i64 %282
%284 = load i32, i32* %283
switch i32 %284, label %291 [
i32 1, label %289
i32 2, label %287
i32 3, label %285
]
285: ; preds = %280
%286 = add nsw i32 %255, %281
br label %291
287: ; preds = %280
%288 = add nsw i32 %257, %281
br label %291
289: ; preds = %280
%290 = add nsw i32 %258, %281
br label %291
291: ; preds = %289, %287, %285, %280
%292 = phi i32 [ %290, %289 ], [ %288, %287 ], [ %286, %285 ], [ %281, %280 ]
%293 = add nuw nsw i64 %270, 2
%294 = icmp eq i64 %293, 100
br i1 %294, label %267, label %269
295: ; preds = %15, %89, %171, %0, %267
%296 = phi i32 [ 0, %267 ], [ 1, %0 ], [ 1, %171 ], [ 1, %89 ], [ 1, %15 ]
ret i32 %296
}