#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*/ count_types_in_hand(int **, int *);
int /*<<< orphan*/ get_num_sequence(int **, int *);
scalar_t__ is_hand_sequential(int *);
int max(int *);
int min(int *);
int /*<<< orphan*/ n_of_a_kind(int *, int *, int *);
int sum(int *);
void get_highest_score_in_hand(int hand[5][2], int score[2], int num_seq[5]) {
  int types, n_of_kind_weight, n_of_kind[2] = {0};
  get_num_sequence(hand, num_seq);
  count_types_in_hand(hand, &types);
  n_of_a_kind(num_seq, n_of_kind, &n_of_kind_weight);
  if (types == 1) {
    if (is_hand_sequential(num_seq)) {
      if (min(num_seq) == 10) {
        score[0] = 9;
        score[1] = 0;
        return;
      } else {
        score[0] = 8;
        score[1] = sum(num_seq);
        return;
      }
    } else {
      score[0] = 5;
      score[1] = sum(num_seq);
      return;
    }
  } else if (types == 4 && (n_of_kind[0] == 4 || n_of_kind[1] == 4)) {
    score[0] = 7;
    score[1] = n_of_kind_weight;
    return;
  } else if (is_hand_sequential(num_seq)) {
    score[0] = 4;
    score[1] = sum(num_seq);
  } else if (types >= 3 && (n_of_kind[0] == 3 || n_of_kind[1] == 3)) {
    if (n_of_kind[0] == 2 || n_of_kind[1] == 2) {
      score[0] = 6;
      score[1] = n_of_kind_weight;
      return;
    } else {
      score[0] = 3;
      score[1] = n_of_kind_weight;
      return;
    }
  } else if (types >= 2 && (n_of_kind[0] == 2 || n_of_kind[1] == 2)) {
    if (n_of_kind[0] == 2 && n_of_kind[1] == 2) {
      score[0] = 2;
      score[1] = n_of_kind_weight;
      return;
    } else {
      score[0] = 1;
      score[1] = n_of_kind_weight;
      return;
    }
  } else {
    score[0] = 0;
    score[1] = max(num_seq);
    return;
  }
}


x86 assembly (clang, -O0):
<get_highest_score_in_hand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1060 <memset@plt>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   10a0 <get_num_sequence@plt>
mov    -0x8(%rbp),%rdi
lea    -0x1c(%rbp),%rsi
call   1030 <count_types_in_hand@plt>
mov    -0x18(%rbp),%rdi
lea    -0x28(%rbp),%rsi
lea    -0x20(%rbp),%rdx
call   1080 <n_of_a_kind@plt>
cmpl   $0x1,-0x1c(%rbp)
jne    125a <get_highest_score_in_hand+0xda>
mov    -0x18(%rbp),%rdi
call   1090 <is_hand_sequential@plt>
cmp    $0x0,%rax
je     1239 <get_highest_score_in_hand+0xb9>
mov    -0x18(%rbp),%rdi
call   1040 <min@plt>
cmp    $0xa,%eax
jne    1218 <get_highest_score_in_hand+0x98>
mov    -0x10(%rbp),%rax
movl   $0x9,(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
mov    -0x10(%rbp),%rax
movl   $0x8,(%rax)
mov    -0x18(%rbp),%rdi
call   1070 <sum@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
mov    -0x10(%rbp),%rax
movl   $0x5,(%rax)
mov    -0x18(%rbp),%rdi
call   1070 <sum@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
cmpl   $0x4,-0x1c(%rbp)
jne    1291 <get_highest_score_in_hand+0x111>
cmpl   $0x4,-0x28(%rbp)
je     1278 <get_highest_score_in_hand+0xf8>
cmpl   $0x4,-0x24(%rbp)
jne    1291 <get_highest_score_in_hand+0x111>
mov    -0x10(%rbp),%rax
movl   $0x7,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
mov    -0x18(%rbp),%rdi
call   1090 <is_hand_sequential@plt>
cmp    $0x0,%rax
je     12c5 <get_highest_score_in_hand+0x145>
mov    -0x10(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x18(%rbp),%rdi
call   1070 <sum@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13ae <get_highest_score_in_hand+0x22e>
cmpl   $0x3,-0x1c(%rbp)
jl     1329 <get_highest_score_in_hand+0x1a9>
cmpl   $0x3,-0x28(%rbp)
je     12e3 <get_highest_score_in_hand+0x163>
cmpl   $0x3,-0x24(%rbp)
jne    1329 <get_highest_score_in_hand+0x1a9>
cmpl   $0x2,-0x28(%rbp)
je     12f7 <get_highest_score_in_hand+0x177>
cmpl   $0x2,-0x24(%rbp)
jne    1310 <get_highest_score_in_hand+0x190>
mov    -0x10(%rbp),%rax
movl   $0x6,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
mov    -0x10(%rbp),%rax
movl   $0x3,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
cmpl   $0x2,-0x1c(%rbp)
jl     138d <get_highest_score_in_hand+0x20d>
cmpl   $0x2,-0x28(%rbp)
je     1347 <get_highest_score_in_hand+0x1c7>
cmpl   $0x2,-0x24(%rbp)
jne    138d <get_highest_score_in_hand+0x20d>
cmpl   $0x2,-0x28(%rbp)
jne    1374 <get_highest_score_in_hand+0x1f4>
cmpl   $0x2,-0x24(%rbp)
jne    1374 <get_highest_score_in_hand+0x1f4>
mov    -0x10(%rbp),%rax
movl   $0x2,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
mov    -0x10(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rdi
call   1050 <max@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    13b8 <get_highest_score_in_hand+0x238>
jmp    13b3 <get_highest_score_in_hand+0x233>
jmp    13b8 <get_highest_score_in_hand+0x238>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_highest_score_in_hand>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
movq   $0x0,0x10(%rsp)
mov    %rdx,%rsi
call   1090 <get_num_sequence@plt>
lea    0x1c(%rsp),%rsi
mov    %rbx,%rdi
call   1030 <count_types_in_hand@plt>
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
mov    %r15,%rdi
call   1070 <n_of_a_kind@plt>
mov    0x1c(%rsp),%eax
cmp    $0x4,%eax
je     11e5 <get_highest_score_in_hand+0x75>
cmp    $0x1,%eax
jne    11f3 <get_highest_score_in_hand+0x83>
mov    %r15,%rdi
call   1080 <is_hand_sequential@plt>
test   %rax,%rax
je     124c <get_highest_score_in_hand+0xdc>
mov    %r15,%rdi
call   1040 <min@plt>
cmp    $0xa,%eax
jne    1255 <get_highest_score_in_hand+0xe5>
movl   $0x9,(%r14)
xor    %eax,%eax
jmp    1264 <get_highest_score_in_hand+0xf4>
cmpl   $0x4,0x10(%rsp)
je     123f <get_highest_score_in_hand+0xcf>
cmpl   $0x4,0x14(%rsp)
je     123f <get_highest_score_in_hand+0xcf>
mov    %r15,%rdi
call   1080 <is_hand_sequential@plt>
test   %rax,%rax
je     1209 <get_highest_score_in_hand+0x99>
movl   $0x4,(%r14)
jmp    125c <get_highest_score_in_hand+0xec>
mov    0x1c(%rsp),%eax
cmp    $0x3,%eax
jl     1272 <get_highest_score_in_hand+0x102>
mov    0x10(%rsp),%ecx
mov    0x14(%rsp),%eax
cmp    $0x3,%ecx
je     1224 <get_highest_score_in_hand+0xb4>
cmp    $0x3,%eax
jne    127f <get_highest_score_in_hand+0x10f>
cmp    $0x2,%ecx
je     12b1 <get_highest_score_in_hand+0x141>
cmp    $0x2,%eax
je     12b1 <get_highest_score_in_hand+0x141>
movl   $0x3,(%r14)
mov    0xc(%rsp),%eax
jmp    1264 <get_highest_score_in_hand+0xf4>
movl   $0x7,(%r14)
mov    0xc(%rsp),%eax
jmp    1264 <get_highest_score_in_hand+0xf4>
movl   $0x5,(%r14)
jmp    125c <get_highest_score_in_hand+0xec>
movl   $0x8,(%r14)
mov    %r15,%rdi
call   1060 <sum@plt>
mov    %eax,0x4(%r14)
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x2,%eax
jne    1289 <get_highest_score_in_hand+0x119>
mov    0x10(%rsp),%ecx
mov    0x14(%rsp),%eax
cmp    $0x2,%ecx
je     129a <get_highest_score_in_hand+0x12a>
cmp    $0x2,%eax
je     129a <get_highest_score_in_hand+0x12a>
movl   $0x0,(%r14)
mov    %r15,%rdi
call   1050 <max@plt>
jmp    1264 <get_highest_score_in_hand+0xf4>
cmp    $0x2,%ecx
jne    12be <get_highest_score_in_hand+0x14e>
cmp    $0x2,%eax
jne    12be <get_highest_score_in_hand+0x14e>
movl   $0x2,(%r14)
mov    0xc(%rsp),%eax
jmp    1264 <get_highest_score_in_hand+0xf4>
movl   $0x6,(%r14)
mov    0xc(%rsp),%eax
jmp    1264 <get_highest_score_in_hand+0xf4>
movl   $0x1,(%r14)
mov    0xc(%rsp),%eax
jmp    1264 <get_highest_score_in_hand+0xf4>

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

LLVM IR (-O2):
define void @get_highest_score_in_hand([2 x i32]* %0, i32* nocapture writeonly %1, i32* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i64
%7 = bitcast i64* %6 to [2 x i32]*
%8 = bitcast i32* %4 to i8*
%9 = bitcast i32* %5 to i8*
%10 = bitcast i64* %6 to i8*
store i64 0, i64* %6
%11 = bitcast [2 x i32]* %0 to i32**
%12 = tail call i32 @get_num_sequence(i32** %11, i32* %2)
%13 = call i32 @count_types_in_hand(i32** %11, i32* %4)
%14 = bitcast i64* %6 to i32*
%15 = call i32 @n_of_a_kind(i32* %2, i32* %14, i32* %5)
%16 = load i32, i32* %4
switch i32 %16, label %37 [
i32 1, label %17
i32 4, label %28
]
17: ; preds = %3
%18 = call i64 @is_hand_sequential(i32* %2)
%19 = icmp eq i64 %18, 0
br i1 %19, label %26, label %20
20: ; preds = %17
%21 = call i32 @min(i32* %2)
%22 = icmp eq i32 %21, 10
br i1 %22, label %23, label %24
23: ; preds = %20
store i32 9, i32* %1
br label %80
24: ; preds = %20
store i32 8, i32* %1
%25 = call i32 @sum(i32* %2)
br label %80
26: ; preds = %17
store i32 5, i32* %1
%27 = call i32 @sum(i32* %2)
br label %80
28: ; preds = %3
%29 = load i32, i32* %14
%30 = icmp eq i32 %29, 4
%31 = getelementptr inbounds [2 x i32], [2 x i32]* %7, i64 0, i64 1
%32 = load i32, i32* %31
%33 = icmp eq i32 %32, 4
%34 = select i1 %30, i1 true, i1 %33
br i1 %34, label %35, label %37
35: ; preds = %28
store i32 7, i32* %1
%36 = load i32, i32* %5
br label %80
37: ; preds = %3, %28
%38 = call i64 @is_hand_sequential(i32* %2)
%39 = icmp eq i64 %38, 0
br i1 %39, label %42, label %40
40: ; preds = %37
store i32 4, i32* %1
%41 = call i32 @sum(i32* %2)
br label %80
42: ; preds = %37
%43 = load i32, i32* %4
%44 = icmp sgt i32 %43, 2
br i1 %44, label %45, label %60
45: ; preds = %42
%46 = load i32, i32* %14
%47 = icmp eq i32 %46, 3
%48 = getelementptr inbounds [2 x i32], [2 x i32]* %7, i64 0, i64 1
%49 = load i32, i32* %48
%50 = icmp eq i32 %49, 3
%51 = select i1 %47, i1 true, i1 %50
br i1 %51, label %52, label %66
52: ; preds = %45
%53 = icmp eq i32 %46, 2
%54 = icmp eq i32 %49, 2
%55 = select i1 %53, i1 true, i1 %54
br i1 %55, label %56, label %58
56: ; preds = %52
store i32 6, i32* %1
%57 = load i32, i32* %5
br label %80
58: ; preds = %52
store i32 3, i32* %1
%59 = load i32, i32* %5
br label %80
60: ; preds = %42
%61 = icmp eq i32 %43, 2
br i1 %61, label %62, label %78
62: ; preds = %60
%63 = load i32, i32* %14
%64 = getelementptr inbounds [2 x i32], [2 x i32]* %7, i64 0, i64 1
%65 = load i32, i32* %64
br label %66
66: ; preds = %62, %45
%67 = phi i32 [ %65, %62 ], [ %49, %45 ]
%68 = phi i32 [ %63, %62 ], [ %46, %45 ]
%69 = icmp eq i32 %68, 2
%70 = icmp eq i32 %67, 2
%71 = select i1 %69, i1 true, i1 %70
br i1 %71, label %72, label %78
72: ; preds = %66
%73 = select i1 %69, i1 %70, i1 false
br i1 %73, label %74, label %76
74: ; preds = %72
store i32 2, i32* %1
%75 = load i32, i32* %5
br label %80
76: ; preds = %72
store i32 1, i32* %1
%77 = load i32, i32* %5
br label %80
78: ; preds = %66, %60
store i32 0, i32* %1
%79 = call i32 @max(i32* %2)
br label %80
80: ; preds = %40, %78, %76, %74, %58, %56, %35, %26, %24, %23
%81 = phi i32 [ %41, %40 ], [ %79, %78 ], [ %77, %76 ], [ %75, %74 ], [ %59, %58 ], [ %57, %56 ], [ %36, %35 ], [ %27, %26 ], [ %25, %24 ], [ 0, %23 ]
%82 = getelementptr inbounds i32, i32* %1, i64 1
store i32 %81, i32* %82
ret void
}