#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 */
struct cept {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ add_function(struct cept *, char *);
int /*<<< orphan*/ add_long(struct cept *, char *, long);
int /*<<< orphan*/ add_message(struct cept *, char *);
int /*<<< orphan*/ add_source(struct cept *, char *);
struct cept *new_cept(int, int, int);
double positive_angle(double *, double *, double *);
void sort_points(double center[3], double radius, double axis[3], int n_points,
                 double circle_points[][3], short orn[], short indices[]) {
  int k, index0, index1, base, n_e, edg_idx;
  int n_start, n_stop, pnt;
  int n_sorted;
  double minimum_angle;
  int point_used[100];
  double point_angle[100];
  double point_vector[100][3];
  char message[255];
  struct cept *ex;
  if (n_points % 2 != 0) {
    ex = new_cept(1, 7, 1);
    add_function(ex, "sort_points");
    add_message(ex, "odd number of points on circle");
    return;
  }
  n_start = 0;
  n_stop = 0;
  for (pnt = 0; pnt < n_points; ++pnt) {
    if (orn[pnt])
      n_stop++;
    else
      n_start++;
    for (k = 0; k < 3; k++)
      point_vector[pnt][k] = (circle_points[pnt][k] - center[k]) / radius;
  }
  if (n_start != n_stop) {
    ex = new_cept(1, 4, 1);
    add_function(ex, "sort_points");
    add_long(ex, "number of start points", (long)n_start);
    add_long(ex, "number of stop points", (long)n_stop);
    return;
  }
  base = -1;
  for (pnt = 0; pnt < n_points; pnt++)
    if (orn[pnt] == 0) {
      base = pnt;
      break;
    }
  if (base < 0) {
    ex = new_cept(1, 4, 1);
    add_function(ex, "sort_points");
    add_message(ex, "base point not found");
    return;
  }
  for (pnt = 0; pnt < n_points; pnt++)
    point_angle[pnt] =
        positive_angle(point_vector[base], point_vector[pnt], axis);
  point_angle[base] = 0.0;
  for (pnt = 0; pnt < n_points; pnt++)
    point_used[pnt] = 0;
  n_e = n_points / 2;
  n_sorted = 0;
  for (edg_idx = 0; edg_idx < n_e; edg_idx++) {
    index0 = -1;
    for (pnt = 0; pnt < n_points; pnt++) {
      if (point_used[pnt])
        continue;
      if (orn[pnt] == 1)
        continue;
      index0 = pnt;
      break;
    }
    if (index0 < 0) {
      ex = new_cept(1, 4, 1);
      add_function(ex, "sort_points");
      add_message(ex, "starting vertex not found");
      return;
    }
    if (edg_idx == 0 && index0 != base) {
      ex = new_cept(1, 4, 1);
      add_function(ex, "sort_points");
      add_message(ex, "first start point is not the base point");
      return;
    }
    point_used[index0] = 1;
    minimum_angle = 2 * 3.14159265358979323846;
    index1 = -1;
    for (pnt = 0; pnt < n_points; pnt++) {
      if (point_used[pnt])
        continue;
      if (orn[pnt] == 0)
        continue;
      if (point_angle[pnt] <= point_angle[index0])
        continue;
      if (point_angle[pnt] < minimum_angle) {
        index1 = pnt;
        minimum_angle = point_angle[pnt];
      }
    }
    if (index1 < 0) {
      ex = new_cept(1, 4, 1);
      add_function(ex, "sort_points");
      add_message(ex, "ending point not found");
      return;
    }
    point_used[index1] = 1;
    if (n_sorted >= n_points - 1) {
      ex = new_cept(7, 12, 1);
      add_function(ex, "sort_points");
      add_long(ex, "number of points", (long)n_points);
      add_long(ex, "number of sorted points", (long)n_sorted);
      return;
    }
    indices[n_sorted] = (short)index0;
    n_sorted++;
    indices[n_sorted] = (short)index1;
    n_sorted++;
  }
  if (n_sorted != n_points) {
    ex = new_cept(7, 14, 1);
    add_function(ex, "sort_points");
    add_source(ex, "mscircle.c");
    add_long(ex, "number of points", (long)n_points);
    add_long(ex, "number of sorted points", (long)n_sorted);
    return;
  }
}


x86 assembly (clang, -O0):
<sort_points>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf90,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11de <sort_points+0x7e>
mov    $0x1,%edx
mov    $0x7,%esi
mov    %edx,%edi
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0xe47(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
lea    0xe40(%rip),%rsi
call   1060 <add_message@plt>
jmp    17d5 <sort_points+0x675>
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12a0 <sort_points+0x140>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
cmpw   $0x0,(%rax,%rcx,2)
je     1220 <sort_points+0xc0>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1229 <sort_points+0xc9>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    128d <sort_points+0x12d>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x10(%rbp),%xmm0
movslq -0x5c(%rbp),%rcx
lea    -0xe80(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1230 <sort_points+0xd0>
jmp    1292 <sort_points+0x132>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11f3 <sort_points+0x93>
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     130a <sort_points+0x1aa>
mov    $0x1,%edx
mov    $0x4,%esi
mov    %edx,%edi
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0xd36(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
movslq -0x54(%rbp),%rdx
lea    0xd4a(%rip),%rsi
call   1080 <add_long@plt>
mov    -0xf88(%rbp),%rdi
movslq -0x58(%rbp),%rdx
lea    0xd4a(%rip),%rsi
call   1080 <add_long@plt>
jmp    17d5 <sort_points+0x675>
movl   $0xffffffff,-0x48(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1357 <sort_points+0x1f7>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1344 <sort_points+0x1e4>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1357 <sort_points+0x1f7>
jmp    1349 <sort_points+0x1e9>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1318 <sort_points+0x1b8>
cmpl   $0x0,-0x48(%rbp)
jge    13a4 <sort_points+0x244>
mov    $0x1,%edx
mov    $0x4,%esi
mov    %edx,%edi
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0xc81(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
lea    0xcc6(%rip),%rsi
call   1060 <add_message@plt>
jmp    17d5 <sort_points+0x675>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13ff <sort_points+0x29f>
movslq -0x48(%rbp),%rax
lea    -0xe80(%rbp),%rdi
imul   $0x18,%rax,%rax
add    %rax,%rdi
movslq -0x5c(%rbp),%rax
lea    -0xe80(%rbp),%rsi
imul   $0x18,%rax,%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
call   1070 <positive_angle@plt>
movslq -0x5c(%rbp),%rax
movsd  %xmm0,-0x520(%rbp,%rax,8)
ff ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13ab <sort_points+0x24b>
movslq -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x520(%rbp,%rax,8)
ff ff
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    143f <sort_points+0x2df>
movslq -0x5c(%rbp),%rax
movl   $0x0,-0x200(%rbp,%rax,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1416 <sort_points+0x2b6>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    175a <sort_points+0x5fa>
movl   $0xffffffff,-0x40(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14cb <sort_points+0x36b>
movslq -0x5c(%rbp),%rax
cmpl   $0x0,-0x200(%rbp,%rax,4)
je     1498 <sort_points+0x338>
jmp    14bd <sort_points+0x35d>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x1,%eax
jne    14b2 <sort_points+0x352>
jmp    14bd <sort_points+0x35d>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    14cb <sort_points+0x36b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1475 <sort_points+0x315>
cmpl   $0x0,-0x40(%rbp)
jge    1518 <sort_points+0x3b8>
mov    $0x1,%edx
mov    $0x4,%esi
mov    %edx,%edi
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0xb0d(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
lea    0xb67(%rip),%rsi
call   1060 <add_message@plt>
jmp    17d5 <sort_points+0x675>
cmpl   $0x0,-0x50(%rbp)
jne    1571 <sort_points+0x411>
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     1571 <sort_points+0x411>
mov    $0x1,%edx
mov    $0x4,%esi
mov    %edx,%edi
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0xab4(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
lea    0xb28(%rip),%rsi
call   1060 <add_message@plt>
jmp    17d5 <sort_points+0x675>
movslq -0x40(%rbp),%rax
movl   $0x1,-0x200(%rbp,%rax,4)
movsd  0xa78(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0xffffffff,-0x44(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1648 <sort_points+0x4e8>
movslq -0x5c(%rbp),%rax
cmpl   $0x0,-0x200(%rbp,%rax,4)
je     15be <sort_points+0x45e>
jmp    163a <sort_points+0x4da>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    15d8 <sort_points+0x478>
jmp    163a <sort_points+0x4da>
movslq -0x5c(%rbp),%rax
movsd  -0x520(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40(%rbp),%rax
movsd  -0x520(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jb     1601 <sort_points+0x4a1>
jmp    163a <sort_points+0x4da>
movslq -0x5c(%rbp),%rax
movsd  -0x520(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1635 <sort_points+0x4d5>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movslq -0x5c(%rbp),%rax
movsd  -0x520(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x68(%rbp)
jmp    163a <sort_points+0x4da>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    159b <sort_points+0x43b>
cmpl   $0x0,-0x44(%rbp)
jge    1695 <sort_points+0x535>
mov    $0x1,%edx
mov    $0x4,%esi
mov    %edx,%edi
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0x990(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
lea    0xa2c(%rip),%rsi
call   1060 <add_message@plt>
jmp    17d5 <sort_points+0x675>
movslq -0x44(%rbp),%rax
movl   $0x1,-0x200(%rbp,%rax,4)
mov    -0x60(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     1716 <sort_points+0x5b6>
mov    $0x7,%edi
mov    $0xc,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0x92a(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
movslq -0x1c(%rbp),%rdx
lea    0x9d9(%rip),%rsi
call   1080 <add_long@plt>
mov    -0xf88(%rbp),%rdi
movslq -0x60(%rbp),%rdx
lea    0x9d3(%rip),%rsi
call   1080 <add_long@plt>
jmp    17d5 <sort_points+0x675>
mov    -0x40(%rbp),%eax
mov    %ax,%dx
mov    -0x38(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x44(%rbp),%eax
mov    %ax,%dx
mov    -0x38(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    145b <sort_points+0x2fb>
mov    -0x60(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     17d5 <sort_points+0x675>
mov    $0x7,%edi
mov    $0xe,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,-0xf88(%rbp)
mov    -0xf88(%rbp),%rdi
lea    0x879(%rip),%rsi
call   1050 <add_function@plt>
mov    -0xf88(%rbp),%rdi
lea    0x955(%rip),%rsi
call   1040 <add_source@plt>
mov    -0xf88(%rbp),%rdi
movslq -0x1c(%rbp),%rdx
lea    0x915(%rip),%rsi
call   1080 <add_long@plt>
mov    -0xf88(%rbp),%rdi
movslq -0x60(%rbp),%rdx
lea    0x90f(%rip),%rsi
call   1080 <add_long@plt>
add    $0xf90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_points>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe48,%rsp
test   $0x1,%dl
jne    11b0 <sort_points+0x40>
test   %edx,%edx
jle    1469 <sort_points+0x2f9>
mov    %rsi,%r13
mov    %edx,%r14d
movupd (%rdi),%xmm12
movsd  0x10(%rdi),%xmm13
cmp    $0x4,%edx
jae    11e2 <sort_points+0x72>
xor    %r11d,%r11d
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    13c4 <sort_points+0x254>
mov    $0x1,%edi
mov    $0x7,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0xe4a(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
lea    0xe47(%rip),%rsi
jmp    1496 <sort_points+0x326>
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
movapd %xmm12,%xmm11
unpcklpd %xmm12,%xmm11
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,%xmm15
punpcklqdq %xmm0,%xmm15
movapd %xmm12,0x10(%rsp)
unpckhpd %xmm12,%xmm12
movapd %xmm13,(%rsp)
unpcklpd %xmm13,%xmm13
lea    0x4(%r8),%rbp
lea    0x0(,%r14,8),%rsi
and    $0xffffffffffffffe0,%rsi
lea    (%rsi,%rsi,2),%rsi
pxor   %xmm0,%xmm0
xor    %edi,%edi
movdqa 0xdc3(%rip),%xmm14
pxor   %xmm2,%xmm2
pxor   %xmm7,%xmm7
pxor   %xmm5,%xmm5
pxor   %xmm3,%xmm3
nopl   (%rax)
movd   -0x4(%rbp),%xmm1
movd   0x0(%rbp),%xmm4
pshuflw $0xd4,%xmm1,%xmm1
pcmpeqw %xmm0,%xmm1
movdqa %xmm1,%xmm6
pand   %xmm14,%xmm6
paddd  %xmm6,%xmm5
pshuflw $0xd4,%xmm4,%xmm4
pcmpeqw %xmm0,%xmm4
movdqa %xmm4,%xmm6
pand   %xmm14,%xmm6
paddd  %xmm6,%xmm3
pandn  %xmm14,%xmm1
paddd  %xmm1,%xmm2
pandn  %xmm14,%xmm4
paddd  %xmm4,%xmm7
movsd  (%rcx,%rdi,1),%xmm1
movsd  0x8(%rcx,%rdi,1),%xmm4
movsd  0x10(%rcx,%rdi,1),%xmm8
movhpd 0x18(%rcx,%rdi,1),%xmm1
movsd  0x30(%rcx,%rdi,1),%xmm6
movhpd 0x48(%rcx,%rdi,1),%xmm6
subpd  %xmm11,%xmm1
divpd  %xmm15,%xmm1
movhpd 0x20(%rcx,%rdi,1),%xmm4
movsd  0x38(%rcx,%rdi,1),%xmm9
movhpd 0x50(%rcx,%rdi,1),%xmm9
subpd  %xmm12,%xmm4
divpd  %xmm15,%xmm4
movhpd 0x28(%rcx,%rdi,1),%xmm8
subpd  %xmm13,%xmm8
divpd  %xmm15,%xmm8
movapd %xmm1,%xmm10
unpcklpd %xmm4,%xmm10
movsd  %xmm8,%xmm1
movhlps %xmm4,%xmm8
movsd  0x40(%rcx,%rdi,1),%xmm4
movhpd 0x58(%rcx,%rdi,1),%xmm4
movaps %xmm8,0x500(%rsp,%rdi,1)
movapd %xmm1,0x4f0(%rsp,%rdi,1)
subpd  %xmm11,%xmm6
divpd  %xmm15,%xmm6
subpd  %xmm12,%xmm9
divpd  %xmm15,%xmm9
subpd  %xmm13,%xmm4
divpd  %xmm15,%xmm4
movapd %xmm10,0x4e0(%rsp,%rdi,1)
movapd %xmm6,%xmm1
unpcklpd %xmm9,%xmm1
movsd  %xmm4,%xmm6
movhlps %xmm9,%xmm4
movaps %xmm4,0x530(%rsp,%rdi,1)
movapd %xmm6,0x520(%rsp,%rdi,1)
movapd %xmm1,0x510(%rsp,%rdi,1)
add    $0x60,%rdi
add    $0x8,%rbp
cmp    %rdi,%rsi
jne    1250 <sort_points+0xe0>
paddd  %xmm5,%xmm3
pshufd $0x55,%xmm3,%xmm0
paddd  %xmm3,%xmm0
movd   %xmm0,%ebx
paddd  %xmm2,%xmm7
pshufd $0x55,%xmm7,%xmm0
paddd  %xmm7,%xmm0
movd   %xmm0,%ebp
cmp    %r14,%r11
movapd 0x20(%rsp),%xmm0
movapd 0x10(%rsp),%xmm12
movapd (%rsp),%xmm13
je     1432 <sort_points+0x2c2>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%r11,%r11,2),%rax
lea    0x10(,%rax,8),%rax
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
xor    %edi,%edi
cmpw   $0x0,(%r8,%r11,2)
setne  %sil
sete   %dil
add    %edi,%ebx
add    %esi,%ebp
movupd -0x10(%rcx,%rax,1),%xmm2
subpd  %xmm12,%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x4d0(%rsp,%rax,1)
movsd  (%rcx,%rax,1),%xmm2
subsd  %xmm13,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x4e0(%rsp,%rax,1)
add    $0x1,%r11
add    $0x18,%rax
cmp    %r11,%r14
jne    13e0 <sort_points+0x270>
cmp    %ebp,%ebx
jne    14af <sort_points+0x33f>
test   %edx,%edx
jle    1469 <sort_points+0x2f9>
lea    0x4e0(%rsp),%rbx
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nop
cmpw   $0x0,(%r8,%r15,2)
je     1508 <sort_points+0x398>
add    $0x1,%r15
add    $0x18,%rbx
cmp    %r15,%r14
jne    1450 <sort_points+0x2e0>
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0xb91(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
lea    0xbda(%rip),%rsi
mov    %rbx,%rdi
add    $0xe48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <add_message@plt>
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,%r14
lea    0xb4b(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
mov    %ebx,%edx
lea    0xb65(%rip),%rsi
mov    %r14,%rdi
call   1090 <add_long@plt>
mov    %ebp,%edx
lea    0xb6b(%rip),%rsi
mov    %r14,%rdi
add    $0xe48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1090 <add_long@plt>
mov    %r8,0x10(%rsp)
mov    %r9,(%rsp)
mov    %rdx,0x20(%rsp)
lea    0x4e0(%rsp),%rbp
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
call   1080 <positive_angle@plt>
movsd  %xmm0,0x1c0(%rsp,%r12,8)
add    $0x1,%r12
add    $0x18,%rbp
cmp    %r12,%r14
jne    1530 <sort_points+0x3c0>
movq   $0x0,0x1c0(%rsp,%r15,8)
lea    0x0(,%r14,4),%rdx
lea    0x30(%rsp),%rdi
xor    %r12d,%r12d
xor    %esi,%esi
call   1040 <memset@plt>
cmp    $0x2,%r14d
mov    0x20(%rsp),%r9
jl     1679 <sort_points+0x509>
mov    %r9d,%eax
shr    $0x1f,%eax
add    %r9d,%eax
sar    %eax
lea    -0x1(%r9),%r8d
xor    %r12d,%r12d
movsd  0xa6f(%rip),%xmm0
xor    %r10d,%r10d
mov    0x10(%rsp),%rdx
xor    %esi,%esi
jmp    15bd <sort_points+0x44d>
nopl   (%rax)
add    $0x1,%rsi
cmp    %rsi,%r14
je     16e0 <sort_points+0x570>
cmpl   $0x0,0x30(%rsp,%rsi,4)
jne    15b0 <sort_points+0x440>
cmpw   $0x1,(%rdx,%rsi,2)
je     15b0 <sort_points+0x440>
test   %r10d,%r10d
jne    15d9 <sort_points+0x469>
cmp    %esi,%r15d
jne    1727 <sort_points+0x5b7>
movl   $0x1,0x30(%rsp,%rsi,4)
mov    $0xffffffff,%edi
xor    %ebp,%ebp
movapd %xmm0,%xmm1
jmp    15fb <sort_points+0x48b>
movapd %xmm2,%xmm1
add    $0x1,%rbp
cmp    %rbp,%r14
je     1636 <sort_points+0x4c6>
cmpl   $0x0,0x30(%rsp,%rbp,4)
jne    15f2 <sort_points+0x482>
cmpw   $0x0,(%rdx,%rbp,2)
je     15f2 <sort_points+0x482>
movsd  0x1c0(%rsp,%rbp,8),%xmm2
movsd  0x1c0(%rsp,%rsi,8),%xmm3
ucomisd %xmm2,%xmm3
setb   %bl
ucomisd %xmm2,%xmm1
seta   %cl
test   %cl,%bl
cmovne %ebp,%edi
jne    15ee <sort_points+0x47e>
movapd %xmm1,%xmm2
jmp    15ee <sort_points+0x47e>
test   %edi,%edi
js     1756 <sort_points+0x5e6>
mov    %edi,%ecx
movl   $0x1,0x30(%rsp,%rcx,4)
cmp    %r8,%r12
jae    1785 <sort_points+0x615>
lea    (%r12,%r12,1),%rcx
mov    (%rsp),%rbp
mov    %si,0x0(%rbp,%r12,2)
or     $0x2,%rcx
mov    %di,0x0(%rbp,%rcx,1)
add    $0x2,%r12
add    $0x1,%r10d
cmp    %eax,%r10d
jne    15a9 <sort_points+0x439>
cmp    %r9d,%r12d
je     1715 <sort_points+0x5a5>
mov    $0x7,%edi
mov    $0xe,%esi
mov    $0x1,%edx
mov    %r9,%rbp
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0x975(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
lea    0xa55(%rip),%rsi
mov    %rbx,%rdi
call   1050 <add_source@plt>
movslq %ebp,%rdx
lea    0xa1a(%rip),%rsi
mov    %rbx,%rdi
call   1090 <add_long@plt>
mov    %r12d,%edx
lea    0xa19(%rip),%rsi
mov    %rbx,%rdi
call   1090 <add_long@plt>
jmp    1715 <sort_points+0x5a5>
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0x91a(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
lea    0x978(%rip),%rsi
mov    %rbx,%rdi
call   1070 <add_message@plt>
add    $0xe48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0x8d3(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
lea    0x94b(%rip),%rsi
jmp    170d <sort_points+0x59d>
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x1,%edx
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0x8a4(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
lea    0x944(%rip),%rsi
jmp    170d <sort_points+0x59d>
mov    $0x7,%edi
mov    $0xc,%esi
mov    $0x1,%edx
mov    %r9,%rbp
call   1030 <new_cept@plt>
mov    %rax,%rbx
lea    0x872(%rip),%rsi
mov    %rax,%rdi
call   1060 <add_function@plt>
movslq %ebp,%rdx
lea    0x926(%rip),%rsi
mov    %rbx,%rdi
call   1090 <add_long@plt>
and    $0xfffffffe,%r12d
lea    0x924(%rip),%rsi
mov    %rbx,%rdi
mov    %r12,%rdx
jmp    16d9 <sort_points+0x569>

LLVM IR (-O0):
%struct.cept = type { i32 }
@.str = [12 x i8] c"sort_points\00"
@.str.1 = [31 x i8] c"odd number of points on circle\00"
@.str.2 = [23 x i8] c"number of start points\00"
@.str.3 = [22 x i8] c"number of stop points\00"
@.str.4 = [21 x i8] c"base point not found\00"
@.str.5 = [26 x i8] c"starting vertex not found\00"
@.str.6 = [40 x i8] c"first start point is not the base point\00"
@.str.7 = [23 x i8] c"ending point not found\00"
@.str.8 = [17 x i8] c"number of points\00"
@.str.9 = [24 x i8] c"number of sorted points\00"
@.str.10 = [11 x i8] c"mscircle.c\00"
define void @sort_points(double* %0, double %1, double* %2, i32 %3, [3 x double]* %4, i16* %5, i16* %6) {
%8 = alloca double*
%9 = alloca double
%10 = alloca double*
%11 = alloca i32
%12 = alloca [3 x double]*
%13 = alloca i16*
%14 = alloca i16*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca double
%26 = alloca [100 x i32]
%27 = alloca [100 x double]
%28 = alloca [100 x [3 x double]]
%29 = alloca [255 x i8]
%30 = alloca %struct.cept*
store double* %0, double** %8
store double %1, double* %9
store double* %2, double** %10
store i32 %3, i32* %11
store [3 x double]* %4, [3 x double]** %12
store i16* %5, i16** %13
store i16* %6, i16** %14
%31 = load i32, i32* %11
%32 = srem i32 %31, 2
%33 = icmp ne i32 %32, 0
br i1 %33, label %34, label %40
34: ; preds = %7
%35 = call %struct.cept* @new_cept(i32 1, i32 7, i32 1)
store %struct.cept* %35, %struct.cept** %30
%36 = load %struct.cept*, %struct.cept** %30
%37 = call i32 @add_function(%struct.cept* %36, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%38 = load %struct.cept*, %struct.cept** %30
%39 = call i32 @add_message(%struct.cept* %38, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0))
br label %347
40: ; preds = %7
store i32 0, i32* %21
store i32 0, i32* %22
store i32 0, i32* %23
br label %41
41: ; preds = %89, %40
%42 = load i32, i32* %23
%43 = load i32, i32* %11
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %92
45: ; preds = %41
%46 = load i16*, i16** %13
%47 = load i32, i32* %23
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i16, i16* %46, i64 %48
%50 = load i16, i16* %49
%51 = icmp ne i16 %50, 0
br i1 %51, label %52, label %55
52: ; preds = %45
%53 = load i32, i32* %22
%54 = add nsw i32 %53, 1
store i32 %54, i32* %22
br label %58
55: ; preds = %45
%56 = load i32, i32* %21
%57 = add nsw i32 %56, 1
store i32 %57, i32* %21
br label %58
58: ; preds = %55, %52
store i32 0, i32* %15
br label %59
59: ; preds = %85, %58
%60 = load i32, i32* %15
%61 = icmp slt i32 %60, 3
br i1 %61, label %62, label %88
62: ; preds = %59
%63 = load [3 x double]*, [3 x double]** %12
%64 = load i32, i32* %23
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [3 x double], [3 x double]* %63, i64 %65
%67 = load i32, i32* %15
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [3 x double], [3 x double]* %66, i64 0, i64 %68
%70 = load double, double* %69
%71 = load double*, double** %8
%72 = load i32, i32* %15
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %71, i64 %73
%75 = load double, double* %74
%76 = fsub double %70, %75
%77 = load double, double* %9
%78 = fdiv double %76, %77
%79 = load i32, i32* %23
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [100 x [3 x double]], [100 x [3 x double]]* %28, i64 0, i64 %80
%82 = load i32, i32* %15
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [3 x double], [3 x double]* %81, i64 0, i64 %83
store double %78, double* %84
br label %85
85: ; preds = %62
%86 = load i32, i32* %15
%87 = add nsw i32 %86, 1
store i32 %87, i32* %15
br label %59
88: ; preds = %59
br label %89
89: ; preds = %88
%90 = load i32, i32* %23
%91 = add nsw i32 %90, 1
store i32 %91, i32* %23
br label %41
92: ; preds = %41
%93 = load i32, i32* %21
%94 = load i32, i32* %22
%95 = icmp ne i32 %93, %94
br i1 %95, label %96, label %108
96: ; preds = %92
%97 = call %struct.cept* @new_cept(i32 1, i32 4, i32 1)
store %struct.cept* %97, %struct.cept** %30
%98 = load %struct.cept*, %struct.cept** %30
%99 = call i32 @add_function(%struct.cept* %98, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%100 = load %struct.cept*, %struct.cept** %30
%101 = load i32, i32* %21
%102 = sext i32 %101 to i64
%103 = call i32 @add_long(%struct.cept* %100, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i64 %102)
%104 = load %struct.cept*, %struct.cept** %30
%105 = load i32, i32* %22
%106 = sext i32 %105 to i64
%107 = call i32 @add_long(%struct.cept* %104, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0), i64 %106)
br label %347
108: ; preds = %92
store i32 -1, i32* %18
store i32 0, i32* %23
br label %109
109: ; preds = %124, %108
%110 = load i32, i32* %23
%111 = load i32, i32* %11
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %127
113: ; preds = %109
%114 = load i16*, i16** %13
%115 = load i32, i32* %23
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i16, i16* %114, i64 %116
%118 = load i16, i16* %117
%119 = sext i16 %118 to i32
%120 = icmp eq i32 %119, 0
br i1 %120, label %121, label %123
121: ; preds = %113
%122 = load i32, i32* %23
store i32 %122, i32* %18
br label %127
123: ; preds = %113
br label %124
124: ; preds = %123
%125 = load i32, i32* %23
%126 = add nsw i32 %125, 1
store i32 %126, i32* %23
br label %109
127: ; preds = %121, %109
%128 = load i32, i32* %18
%129 = icmp slt i32 %128, 0
br i1 %129, label %130, label %136
130: ; preds = %127
%131 = call %struct.cept* @new_cept(i32 1, i32 4, i32 1)
store %struct.cept* %131, %struct.cept** %30
%132 = load %struct.cept*, %struct.cept** %30
%133 = call i32 @add_function(%struct.cept* %132, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%134 = load %struct.cept*, %struct.cept** %30
%135 = call i32 @add_message(%struct.cept* %134, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.4, i64 0, i64 0))
br label %347
136: ; preds = %127
store i32 0, i32* %23
br label %137
137: ; preds = %155, %136
%138 = load i32, i32* %23
%139 = load i32, i32* %11
%140 = icmp slt i32 %138, %139
br i1 %140, label %141, label %158
141: ; preds = %137
%142 = load i32, i32* %18
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [100 x [3 x double]], [100 x [3 x double]]* %28, i64 0, i64 %143
%145 = getelementptr inbounds [3 x double], [3 x double]* %144, i64 0, i64 0
%146 = load i32, i32* %23
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [100 x [3 x double]], [100 x [3 x double]]* %28, i64 0, i64 %147
%149 = getelementptr inbounds [3 x double], [3 x double]* %148, i64 0, i64 0
%150 = load double*, double** %10
%151 = call double @positive_angle(double* %145, double* %149, double* %150)
%152 = load i32, i32* %23
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [100 x double], [100 x double]* %27, i64 0, i64 %153
store double %151, double* %154
br label %155
155: ; preds = %141
%156 = load i32, i32* %23
%157 = add nsw i32 %156, 1
store i32 %157, i32* %23
br label %137
158: ; preds = %137
%159 = load i32, i32* %18
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [100 x double], [100 x double]* %27, i64 0, i64 %160
store double 0.000000e+00, double* %161
store i32 0, i32* %23
br label %162
162: ; preds = %170, %158
%163 = load i32, i32* %23
%164 = load i32, i32* %11
%165 = icmp slt i32 %163, %164
br i1 %165, label %166, label %173
166: ; preds = %162
%167 = load i32, i32* %23
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [100 x i32], [100 x i32]* %26, i64 0, i64 %168
store i32 0, i32* %169
br label %170
170: ; preds = %166
%171 = load i32, i32* %23
%172 = add nsw i32 %171, 1
store i32 %172, i32* %23
br label %162
173: ; preds = %162
%174 = load i32, i32* %11
%175 = sdiv i32 %174, 2
store i32 %175, i32* %19
store i32 0, i32* %24
store i32 0, i32* %20
br label %176
176: ; preds = %326, %173
%177 = load i32, i32* %20
%178 = load i32, i32* %19
%179 = icmp slt i32 %177, %178
br i1 %179, label %180, label %329
180: ; preds = %176
store i32 -1, i32* %16
store i32 0, i32* %23
br label %181
181: ; preds = %203, %180
%182 = load i32, i32* %23
%183 = load i32, i32* %11
%184 = icmp slt i32 %182, %183
br i1 %184, label %185, label %206
185: ; preds = %181
%186 = load i32, i32* %23
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [100 x i32], [100 x i32]* %26, i64 0, i64 %187
%189 = load i32, i32* %188
%190 = icmp ne i32 %189, 0
br i1 %190, label %191, label %192
191: ; preds = %185
br label %203
192: ; preds = %185
%193 = load i16*, i16** %13
%194 = load i32, i32* %23
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i16, i16* %193, i64 %195
%197 = load i16, i16* %196
%198 = sext i16 %197 to i32
%199 = icmp eq i32 %198, 1
br i1 %199, label %200, label %201
200: ; preds = %192
br label %203
201: ; preds = %192
%202 = load i32, i32* %23
store i32 %202, i32* %16
br label %206
203: ; preds = %200, %191
%204 = load i32, i32* %23
%205 = add nsw i32 %204, 1
store i32 %205, i32* %23
br label %181
206: ; preds = %201, %181
%207 = load i32, i32* %16
%208 = icmp slt i32 %207, 0
br i1 %208, label %209, label %215
209: ; preds = %206
%210 = call %struct.cept* @new_cept(i32 1, i32 4, i32 1)
store %struct.cept* %210, %struct.cept** %30
%211 = load %struct.cept*, %struct.cept** %30
%212 = call i32 @add_function(%struct.cept* %211, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%213 = load %struct.cept*, %struct.cept** %30
%214 = call i32 @add_message(%struct.cept* %213, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0))
br label %347
215: ; preds = %206
%216 = load i32, i32* %20
%217 = icmp eq i32 %216, 0
br i1 %217, label %218, label %228
218: ; preds = %215
%219 = load i32, i32* %16
%220 = load i32, i32* %18
%221 = icmp ne i32 %219, %220
br i1 %221, label %222, label %228
222: ; preds = %218
%223 = call %struct.cept* @new_cept(i32 1, i32 4, i32 1)
store %struct.cept* %223, %struct.cept** %30
%224 = load %struct.cept*, %struct.cept** %30
%225 = call i32 @add_function(%struct.cept* %224, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%226 = load %struct.cept*, %struct.cept** %30
%227 = call i32 @add_message(%struct.cept* %226, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.6, i64 0, i64 0))
br label %347
228: ; preds = %218, %215
%229 = load i32, i32* %16
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [100 x i32], [100 x i32]* %26, i64 0, i64 %230
store i32 1, i32* %231
store double 0x401921FB54442D18, double* %25
store i32 -1, i32* %17
store i32 0, i32* %23
br label %232
232: ; preds = %277, %228
%233 = load i32, i32* %23
%234 = load i32, i32* %11
%235 = icmp slt i32 %233, %234
br i1 %235, label %236, label %280
236: ; preds = %232
%237 = load i32, i32* %23
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [100 x i32], [100 x i32]* %26, i64 0, i64 %238
%240 = load i32, i32* %239
%241 = icmp ne i32 %240, 0
br i1 %241, label %242, label %243
242: ; preds = %236
br label %277
243: ; preds = %236
%244 = load i16*, i16** %13
%245 = load i32, i32* %23
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i16, i16* %244, i64 %246
%248 = load i16, i16* %247
%249 = sext i16 %248 to i32
%250 = icmp eq i32 %249, 0
br i1 %250, label %251, label %252
251: ; preds = %243
br label %277
252: ; preds = %243
%253 = load i32, i32* %23
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [100 x double], [100 x double]* %27, i64 0, i64 %254
%256 = load double, double* %255
%257 = load i32, i32* %16
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [100 x double], [100 x double]* %27, i64 0, i64 %258
%260 = load double, double* %259
%261 = fcmp ole double %256, %260
br i1 %261, label %262, label %263
262: ; preds = %252
br label %277
263: ; preds = %252
%264 = load i32, i32* %23
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [100 x double], [100 x double]* %27, i64 0, i64 %265
%267 = load double, double* %266
%268 = load double, double* %25
%269 = fcmp olt double %267, %268
br i1 %269, label %270, label %276
270: ; preds = %263
%271 = load i32, i32* %23
store i32 %271, i32* %17
%272 = load i32, i32* %23
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds [100 x double], [100 x double]* %27, i64 0, i64 %273
%275 = load double, double* %274
store double %275, double* %25
br label %276
276: ; preds = %270, %263
br label %277
277: ; preds = %276, %262, %251, %242
%278 = load i32, i32* %23
%279 = add nsw i32 %278, 1
store i32 %279, i32* %23
br label %232
280: ; preds = %232
%281 = load i32, i32* %17
%282 = icmp slt i32 %281, 0
br i1 %282, label %283, label %289
283: ; preds = %280
%284 = call %struct.cept* @new_cept(i32 1, i32 4, i32 1)
store %struct.cept* %284, %struct.cept** %30
%285 = load %struct.cept*, %struct.cept** %30
%286 = call i32 @add_function(%struct.cept* %285, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%287 = load %struct.cept*, %struct.cept** %30
%288 = call i32 @add_message(%struct.cept* %287, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.7, i64 0, i64 0))
br label %347
289: ; preds = %280
%290 = load i32, i32* %17
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [100 x i32], [100 x i32]* %26, i64 0, i64 %291
store i32 1, i32* %292
%293 = load i32, i32* %24
%294 = load i32, i32* %11
%295 = sub nsw i32 %294, 1
%296 = icmp sge i32 %293, %295
br i1 %296, label %297, label %309
297: ; preds = %289
%298 = call %struct.cept* @new_cept(i32 7, i32 12, i32 1)
store %struct.cept* %298, %struct.cept** %30
%299 = load %struct.cept*, %struct.cept** %30
%300 = call i32 @add_function(%struct.cept* %299, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%301 = load %struct.cept*, %struct.cept** %30
%302 = load i32, i32* %11
%303 = sext i32 %302 to i64
%304 = call i32 @add_long(%struct.cept* %301, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), i64 %303)
%305 = load %struct.cept*, %struct.cept** %30
%306 = load i32, i32* %24
%307 = sext i32 %306 to i64
%308 = call i32 @add_long(%struct.cept* %305, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.9, i64 0, i64 0), i64 %307)
br label %347
309: ; preds = %289
%310 = load i32, i32* %16
%311 = trunc i32 %310 to i16
%312 = load i16*, i16** %14
%313 = load i32, i32* %24
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i16, i16* %312, i64 %314
store i16 %311, i16* %315
%316 = load i32, i32* %24
%317 = add nsw i32 %316, 1
store i32 %317, i32* %24
%318 = load i32, i32* %17
%319 = trunc i32 %318 to i16
%320 = load i16*, i16** %14
%321 = load i32, i32* %24
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i16, i16* %320, i64 %322
store i16 %319, i16* %323
%324 = load i32, i32* %24
%325 = add nsw i32 %324, 1
store i32 %325, i32* %24
br label %326
326: ; preds = %309
%327 = load i32, i32* %20
%328 = add nsw i32 %327, 1
store i32 %328, i32* %20
br label %176
329: ; preds = %176
%330 = load i32, i32* %24
%331 = load i32, i32* %11
%332 = icmp ne i32 %330, %331
br i1 %332, label %333, label %347
333: ; preds = %329
%334 = call %struct.cept* @new_cept(i32 7, i32 14, i32 1)
store %struct.cept* %334, %struct.cept** %30
%335 = load %struct.cept*, %struct.cept** %30
%336 = call i32 @add_function(%struct.cept* %335, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%337 = load %struct.cept*, %struct.cept** %30
%338 = call i32 @add_source(%struct.cept* %337, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.10, i64 0, i64 0))
%339 = load %struct.cept*, %struct.cept** %30
%340 = load i32, i32* %11
%341 = sext i32 %340 to i64
%342 = call i32 @add_long(%struct.cept* %339, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), i64 %341)
%343 = load %struct.cept*, %struct.cept** %30
%344 = load i32, i32* %24
%345 = sext i32 %344 to i64
%346 = call i32 @add_long(%struct.cept* %343, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.9, i64 0, i64 0), i64 %345)
br label %347
347: ; preds = %34, %96, %130, %209, %222, %283, %297, %333, %329
ret void
}

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