#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 */
typedef int int64_t;

/* Variables and functions */
short getLineCoordinates(short listOfCoordinates[][2], const short originLoc[2],
                         const short targetLoc[2]) {
  int64_t targetVector[2], error[2], largerTargetComponent;
  short currentVector[2], previousVector[2], quadrantTransform[2], i;
  short currentLoc[2], previousLoc[2];
  short cellNumber = 0;
  if (originLoc[0] == targetLoc[0] && originLoc[1] == targetLoc[1]) {
    return 0;
  }
  for (i = 0; i <= 1; i++) {
    targetVector[i] = targetLoc[i] - originLoc[i] << 16;
    if (targetVector[i] < 0) {
      targetVector[i] *= -1;
      quadrantTransform[i] = -1;
    } else {
      quadrantTransform[i] = 1;
    }
    currentVector[i] = previousVector[i] = error[i] = 0;
    currentLoc[i] = originLoc[i];
  }
  largerTargetComponent =
      (((targetVector[0]) > (targetVector[1])) ? (targetVector[0])
                                               : (targetVector[1]));
  targetVector[0] = (targetVector[0] << 16) / largerTargetComponent;
  targetVector[1] = (targetVector[1] << 16) / largerTargetComponent;
  do {
    for (i = 0; i <= 1; i++) {
      previousLoc[i] = currentLoc[i];
      currentVector[i] += targetVector[i] >> 16;
      error[i] += (targetVector[i] == (1LL << 16) ? 0 : targetVector[i]);
      if (error[i] >= (1LL << 16) / 2) {
        currentVector[i]++;
        error[i] -= (1LL << 16);
      }
      currentLoc[i] = quadrantTransform[i] * currentVector[i] + originLoc[i];
      listOfCoordinates[cellNumber][i] = currentLoc[i];
    }
    cellNumber++;
  } while (((currentLoc[0]) >= 0 && (currentLoc[0]) < (100 - 20 - 1) &&
            (currentLoc[1]) >= 0 && (currentLoc[1]) < ((31 + 3) - 3 - 2)));
  cellNumber--;
  listOfCoordinates[cellNumber][0] = listOfCoordinates[cellNumber][1] = -1;
  return cellNumber;
}


x86 assembly (clang, -O0):
<getLineCoordinates>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movw   $0x0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movswl (%rax),%eax
mov    -0x20(%rbp),%rcx
movswl (%rcx),%ecx
cmp    %ecx,%eax
jne    114f <getLineCoordinates+0x4f>
mov    -0x18(%rbp),%rax
movswl 0x2(%rax),%eax
mov    -0x20(%rbp),%rcx
movswl 0x2(%rcx),%ecx
cmp    %ecx,%eax
jne    114f <getLineCoordinates+0x4f>
movw   $0x0,-0x2(%rbp)
jmp    1401 <getLineCoordinates+0x301>
movw   $0x0,-0x42(%rbp)
movswl -0x42(%rbp),%eax
cmp    $0x1,%eax
jg     1212 <getLineCoordinates+0x112>
mov    -0x20(%rbp),%rax
movswq -0x42(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x18(%rbp),%rax
movswq -0x42(%rbp),%rdx
movswl (%rax,%rdx,2),%eax
sub    %eax,%ecx
shl    $0x10,%ecx
movswq -0x42(%rbp),%rax
mov    %ecx,-0x28(%rbp,%rax,4)
movswq -0x42(%rbp),%rax
cmpl   $0x0,-0x28(%rbp,%rax,4)
jge    11b9 <getLineCoordinates+0xb9>
movswq -0x42(%rbp),%rax
imul   $0xffffffff,-0x28(%rbp,%rax,4),%ecx
mov    %ecx,-0x28(%rbp,%rax,4)
movswq -0x42(%rbp),%rax
movw   $0xffff,-0x40(%rbp,%rax,2)
jmp    11c5 <getLineCoordinates+0xc5>
movswq -0x42(%rbp),%rax
movw   $0x1,-0x40(%rbp,%rax,2)
movswq -0x42(%rbp),%rax
movl   $0x0,-0x30(%rbp,%rax,4)
movswq -0x42(%rbp),%rax
movw   $0x0,-0x3c(%rbp,%rax,2)
movswq -0x42(%rbp),%rax
movw   $0x0,-0x38(%rbp,%rax,2)
mov    -0x18(%rbp),%rax
movswq -0x42(%rbp),%rcx
mov    (%rax,%rcx,2),%cx
movswq -0x42(%rbp),%rax
mov    %cx,-0x46(%rbp,%rax,2)
mov    -0x42(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x42(%rbp)
jmp    1155 <getLineCoordinates+0x55>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    1229 <getLineCoordinates+0x129>
mov    -0x28(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    122f <getLineCoordinates+0x12f>
mov    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x10,%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x24(%rbp)
movw   $0x0,-0x42(%rbp)
movswl -0x42(%rbp),%eax
cmp    $0x1,%eax
jg     1374 <getLineCoordinates+0x274>
movswq -0x42(%rbp),%rax
mov    -0x46(%rbp,%rax,2),%cx
movswq -0x42(%rbp),%rax
mov    %cx,-0x4a(%rbp,%rax,2)
movswq -0x42(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%edx
sar    $0x10,%edx
movswq -0x42(%rbp),%rax
movswl -0x38(%rbp,%rax,2),%ecx
add    %edx,%ecx
mov    %cx,-0x38(%rbp,%rax,2)
movswq -0x42(%rbp),%rax
movslq -0x28(%rbp,%rax,4),%rax
cmp    $0x10000,%rax
jne    12b3 <getLineCoordinates+0x1b3>
xor    %eax,%eax
mov    %eax,-0x54(%rbp)
jmp    12bf <getLineCoordinates+0x1bf>
movswq -0x42(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%ecx
movswq -0x42(%rbp),%rax
add    -0x30(%rbp,%rax,4),%ecx
mov    %ecx,-0x30(%rbp,%rax,4)
movswq -0x42(%rbp),%rax
movslq -0x30(%rbp,%rax,4),%rax
cmp    $0x8000,%rax
jl     130d <getLineCoordinates+0x20d>
movswq -0x42(%rbp),%rax
mov    -0x38(%rbp,%rax,2),%cx
add    $0x1,%cx
mov    %cx,-0x38(%rbp,%rax,2)
movswq -0x42(%rbp),%rax
movslq -0x30(%rbp,%rax,4),%rcx
sub    $0x10000,%rcx
mov    %ecx,-0x30(%rbp,%rax,4)
movswq -0x42(%rbp),%rax
movswl -0x40(%rbp,%rax,2),%eax
movswq -0x42(%rbp),%rcx
movswl -0x38(%rbp,%rcx,2),%ecx
imul   %ecx,%eax
mov    -0x18(%rbp),%rcx
movswq -0x42(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
mov    %ax,%cx
movswq -0x42(%rbp),%rax
mov    %cx,-0x46(%rbp,%rax,2)
movswq -0x42(%rbp),%rax
mov    -0x46(%rbp,%rax,2),%dx
mov    -0x10(%rbp),%rax
movswq -0x4c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movswq -0x42(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x42(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x42(%rbp)
jmp    1255 <getLineCoordinates+0x155>
mov    -0x4c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x4c(%rbp)
movswl -0x46(%rbp),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x55(%rbp)
jl     13c3 <getLineCoordinates+0x2c3>
movswl -0x46(%rbp),%ecx
xor    %eax,%eax
cmp    $0x4f,%ecx
mov    %al,-0x55(%rbp)
jge    13c3 <getLineCoordinates+0x2c3>
movswl -0x44(%rbp),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x55(%rbp)
jl     13c3 <getLineCoordinates+0x2c3>
movswl -0x44(%rbp),%eax
cmp    $0x1d,%eax
setl   %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    124f <getLineCoordinates+0x14f>
mov    -0x4c(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movswq -0x4c(%rbp),%rcx
movw   $0xffff,0x2(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movswq -0x4c(%rbp),%rcx
movw   $0xffff,(%rax,%rcx,4)
mov    -0x4c(%rbp),%ax
mov    %ax,-0x2(%rbp)
movswl -0x2(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<getLineCoordinates>:
push   %rbp
push   %r15
push   %r14
push   %rbx
movzwl (%rsi),%eax
movzwl (%rdx),%r8d
cmp    %r8w,%ax
jne    1124 <getLineCoordinates+0x24>
movzwl 0x2(%rsi),%ecx
cmp    0x2(%rdx),%cx
jne    1124 <getLineCoordinates+0x24>
xor    %eax,%eax
jmp    11d8 <getLineCoordinates+0xd8>
sub    %eax,%r8d
movzwl 0x2(%rdx),%r9d
movzwl 0x2(%rsi),%eax
sub    %eax,%r9d
xor    %r15d,%r15d
mov    $0xffff,%ax
xor    %ecx,%ecx
xor    %r10d,%r10d
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15d,%ebx
add    $0x1,%eax
lea    -0x10000(%rbx),%r15d
xor    %ebp,%ebp
cmp    $0x8000,%ebx
setge  %bpl
cmovl  %ebx,%r15d
add    %ebp,%r10d
mov    %r10d,%ebx
neg    %ebx
test   $0x8000,%r8d
cmove  %r10d,%ebx
mov    %ecx,%ebp
add    (%rsi),%bx
lea    -0x10000(%rbp),%ecx
xor    %edx,%edx
cmp    $0x8000,%ebp
cmovl  %ebp,%ecx
setge  %dl
add    %edx,%r11d
mov    %r11d,%ebp
neg    %ebp
test   $0x8000,%r9d
movswq %ax,%r14
mov    %bx,(%rdi,%r14,4)
cmove  %r11d,%ebp
add    0x2(%rsi),%bp
mov    %bp,0x2(%rdi,%r14,4)
cmp    $0x4e,%bx
ja     11d0 <getLineCoordinates+0xd0>
test   %bp,%bp
js     11d0 <getLineCoordinates+0xd0>
cmp    $0x1d,%bp
jl     1150 <getLineCoordinates+0x50>
movl   $0xffffffff,(%rdi,%r14,4)
ff
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define signext i16 @getLineCoordinates([2 x i16]* nocapture writeonly %0, i16* nocapture %1, i16* nocapture %2) {
%4 = load i16, i16* %1
%5 = load i16, i16* %2
%6 = icmp eq i16 %4, %5
br i1 %6, label %7, label %13
7: ; preds = %3
%8 = getelementptr inbounds i16, i16* %1, i64 1
%9 = load i16, i16* %8
%10 = getelementptr inbounds i16, i16* %2, i64 1
%11 = load i16, i16* %10
%12 = icmp eq i16 %9, %11
br i1 %12, label %64, label %13
13: ; preds = %7, %3
%14 = getelementptr inbounds i16, i16* %1, i64 1
%15 = zext i16 %5 to i32
%16 = zext i16 %4 to i32
%17 = sub nsw i32 %15, %16
%18 = and i32 %17, 32768
%19 = icmp eq i32 %18, 0
%20 = getelementptr inbounds i16, i16* %2, i64 1
%21 = load i16, i16* %20
%22 = zext i16 %21 to i32
%23 = load i16, i16* %14
%24 = zext i16 %23 to i32
%25 = sub nsw i32 %22, %24
%26 = and i32 %25, 32768
%27 = icmp eq i32 %26, 0
br label %28
28: ; preds = %28, %13
%29 = phi i32 [ 0, %13 ], [ %37, %28 ]
%30 = phi i32 [ 0, %13 ], [ %47, %28 ]
%31 = phi i16 [ 0, %13 ], [ %39, %28 ]
%32 = phi i16 [ 0, %13 ], [ %49, %28 ]
%33 = phi i16 [ 0, %13 ], [ %55, %28 ]
%34 = sext i16 %33 to i64
%35 = icmp sgt i32 %29, 32767
%36 = add nsw i32 %29, -65536
%37 = select i1 %35, i32 %36, i32 %29
%38 = zext i1 %35 to i16
%39 = add i16 %31, %38
%40 = sub i16 0, %39
%41 = select i1 %19, i16 %39, i16 %40
%42 = load i16, i16* %1
%43 = add i16 %41, %42
%44 = getelementptr inbounds [2 x i16], [2 x i16]* %0, i64 %34, i64 0
store i16 %43, i16* %44
%45 = icmp sgt i32 %30, 32767
%46 = add nsw i32 %30, -65536
%47 = select i1 %45, i32 %46, i32 %30
%48 = zext i1 %45 to i16
%49 = add i16 %32, %48
%50 = sub i16 0, %49
%51 = select i1 %27, i16 %49, i16 %50
%52 = load i16, i16* %14
%53 = add i16 %51, %52
%54 = getelementptr inbounds [2 x i16], [2 x i16]* %0, i64 %34, i64 1
store i16 %53, i16* %54
%55 = add i16 %33, 1
%56 = icmp ult i16 %43, 79
%57 = icmp sgt i16 %53, -1
%58 = select i1 %56, i1 %57, i1 false
%59 = icmp slt i16 %53, 29
%60 = select i1 %58, i1 %59, i1 false
br i1 %60, label %28, label %61
61: ; preds = %28
%62 = getelementptr inbounds [2 x i16], [2 x i16]* %0, i64 %34, i64 0
%63 = getelementptr inbounds [2 x i16], [2 x i16]* %0, i64 %34, i64 1
store i16 -1, i16* %63
store i16 -1, i16* %62
br label %64
64: ; preds = %7, %61
%65 = phi i16 [ %33, %61 ], [ 0, %7 ]
ret i16 %65
}