#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 */
char checkEnemyBorderZone(short, short *, short *, int);
int numberOfPlayersInZone(short, short *);
char checkAbleToConquer(short zone, short *graph, short *world, int playerId) {
  char val = checkEnemyBorderZone(zone, graph, world, playerId);
  if (val != 0) {
    short sum = 0;
    short next;
    for (int i = 0; i < 6 && ((next = graph[zone * 6 + i]) != -1); i++) {
      if (world[next * 8 + 3] != -1 && world[next * 8 + 3] != playerId) {
        if (numberOfPlayersInZone(next, world) == 1) {
          for (int j = 4; j < 8; j++) {
            sum += world[next * 8 + j];
          }
        }
      }
    }
    if (sum > world[zone * 8 + 4 + playerId]) {
      val = sum - world[zone * 8 + 4 + playerId];
    } else {
      val = 0;
    }
  }
  return val;
}


x86 assembly (clang, -O0):
<checkAbleToConquer>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x2(%rbp),%ax
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
movswl %ax,%edi
call   1040 <checkEnemyBorderZone@plt>
mov    %al,-0x1d(%rbp)
movsbl -0x1d(%rbp),%eax
cmp    $0x0,%eax
je     12b3 <checkAbleToConquer+0x193>
movw   $0x0,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
xor    %eax,%eax
cmpl   $0x6,-0x28(%rbp)
mov    %al,-0x2d(%rbp)
jge    11a0 <checkAbleToConquer+0x80>
mov    -0x10(%rbp),%rax
movswl -0x2(%rbp),%ecx
imul   $0x6,%ecx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x22(%rbp)
cwtl
cmp    $0xffffffff,%eax
setne  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    11b0 <checkAbleToConquer+0x90>
jmp    1260 <checkAbleToConquer+0x140>
mov    -0x18(%rbp),%rax
movswl -0x22(%rbp),%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0xffffffff,%eax
je     124d <checkAbleToConquer+0x12d>
mov    -0x18(%rbp),%rax
movswl -0x22(%rbp),%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    -0x1c(%rbp),%eax
je     124d <checkAbleToConquer+0x12d>
mov    -0x22(%rbp),%ax
mov    -0x18(%rbp),%rsi
movswl %ax,%edi
call   1030 <numberOfPlayersInZone@plt>
cmp    $0x1,%eax
jne    1248 <checkAbleToConquer+0x128>
movl   $0x4,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    1243 <checkAbleToConquer+0x123>
mov    -0x18(%rbp),%rax
movswl -0x22(%rbp),%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%ecx
movswl -0x20(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120c <checkAbleToConquer+0xec>
jmp    1248 <checkAbleToConquer+0x128>
jmp    124d <checkAbleToConquer+0x12d>
jmp    1252 <checkAbleToConquer+0x132>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    116e <checkAbleToConquer+0x4e>
movswl -0x20(%rbp),%eax
mov    -0x18(%rbp),%rcx
movswl -0x2(%rbp),%edx
shl    $0x3,%edx
add    $0x4,%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    12aa <checkAbleToConquer+0x18a>
movswl -0x20(%rbp),%eax
mov    -0x18(%rbp),%rcx
movswl -0x2(%rbp),%edx
shl    $0x3,%edx
add    $0x4,%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    %al,-0x1d(%rbp)
jmp    12ae <checkAbleToConquer+0x18e>
movb   $0x0,-0x1d(%rbp)
jmp    12b3 <checkAbleToConquer+0x193>
movsbl -0x1d(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<checkAbleToConquer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r14d
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %edi,%ebp
call   1040 <checkEnemyBorderZone@plt>
test   %al,%al
je     11ee <checkAbleToConquer+0xce>
movswl %bp,%eax
mov    %rax,(%rsp)
add    %eax,%eax
lea    (%rax,%rax,2),%eax
cltq
lea    (%r15,%rax,2),%r13
xor    %ebp,%ebp
xor    %r15d,%r15d
jmp    116a <checkAbleToConquer+0x4a>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    $0x6,%rbp
je     11ca <checkAbleToConquer+0xaa>
movswl 0x0(%r13,%rbp,2),%edi
cmp    $0xffffffff,%edi
je     11ca <checkAbleToConquer+0xaa>
movslq %edi,%r12
mov    %r12,%rax
shl    $0x4,%rax
movswl 0x6(%rbx,%rax,1),%eax
cmp    $0xffffffff,%eax
je     1160 <checkAbleToConquer+0x40>
cmp    %r14d,%eax
je     1160 <checkAbleToConquer+0x40>
mov    %rbx,%rsi
call   1030 <numberOfPlayersInZone@plt>
cmp    $0x1,%eax
jne    1160 <checkAbleToConquer+0x40>
shl    $0x3,%r12
or     $0x4,%r12d
movslq %r12d,%rax
movq   (%rbx,%rax,2),%xmm0
pshufd $0x55,%xmm0,%xmm1
paddw  %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrld  $0x10,%xmm0
paddw  %xmm1,%xmm0
movd   %xmm0,%eax
add    %eax,%r15d
jmp    1160 <checkAbleToConquer+0x40>
mov    (%rsp),%rax
lea    (%r14,%rax,8),%eax
add    $0x4,%eax
cltq
movzwl (%rbx,%rax,2),%eax
mov    %r15d,%ecx
sub    %al,%cl
xor    %edx,%edx
cmp    %ax,%r15w
movzbl %cl,%eax
cmovle %edx,%eax
jmp    11f0 <checkAbleToConquer+0xd0>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define signext i8 @checkAbleToConquer(i16 signext %0, i16* %1, i16* %2, i32 %3) {
%5 = tail call signext i8 @checkEnemyBorderZone(i16 signext %0, i16* %1, i16* %2, i32 %3)
%6 = icmp eq i8 %5, 0
br i1 %6, label %57, label %7
7: ; preds = %4
%8 = sext i16 %0 to i32
%9 = mul nsw i32 %8, 6
%10 = sext i32 %9 to i64
br label %11
11: ; preds = %7, %53
%12 = phi i64 [ 0, %7 ], [ %55, %53 ]
%13 = phi i16 [ 0, %7 ], [ %54, %53 ]
%14 = add nsw i64 %12, %10
%15 = getelementptr inbounds i16, i16* %1, i64 %14
%16 = load i16, i16* %15
%17 = icmp eq i16 %16, -1
br i1 %17, label %18, label %31
18: ; preds = %53, %11
%19 = phi i16 [ %54, %53 ], [ %13, %11 ]
%20 = shl nsw i32 %8, 3
%21 = or i32 %20, 4
%22 = add nsw i32 %21, %3
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i16, i16* %2, i64 %23
%25 = load i16, i16* %24
%26 = icmp sgt i16 %19, %25
%27 = trunc i16 %25 to i8
%28 = trunc i16 %19 to i8
%29 = sub i8 %28, %27
%30 = select i1 %26, i8 %29, i8 0
br label %57
31: ; preds = %11
%32 = sext i16 %16 to i32
%33 = shl nsw i32 %32, 3
%34 = or i32 %33, 3
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i16, i16* %2, i64 %35
%37 = load i16, i16* %36
%38 = icmp eq i16 %37, -1
%39 = sext i16 %37 to i32
%40 = icmp eq i32 %39, %3
%41 = or i1 %38, %40
br i1 %41, label %53, label %42
42: ; preds = %31
%43 = tail call i32 @numberOfPlayersInZone(i16 signext %16, i16* %2)
%44 = icmp eq i32 %43, 1
br i1 %44, label %45, label %53
45: ; preds = %42
%46 = or i32 %33, 4
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i16, i16* %2, i64 %47
%49 = bitcast i16* %48 to <4 x i16>*
%50 = load <4 x i16>, <4 x i16>* %49
%51 = call i16 @llvm.vector.reduce.add.v4i16(<4 x i16> %50)
%52 = add i16 %51, %13
br label %53
53: ; preds = %45, %31, %42
%54 = phi i16 [ %13, %42 ], [ %13, %31 ], [ %52, %45 ]
%55 = add nuw nsw i64 %12, 1
%56 = icmp eq i64 %55, 6
br i1 %56, label %18, label %11
57: ; preds = %18, %4
%58 = phi i8 [ %30, %18 ], [ 0, %4 ]
ret i8 %58
}