#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 float y3;
typedef float y1;
typedef int /*<<< orphan*/ temp;

/* Variables and functions */
float atof(char *);
int /*<<< orphan*/ checker1(float, float, float, float, float *, float *,
                            float *, float *);
int /*<<< orphan*/ checker2(float, float, float, float, float *, float *,
                            float *, float *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/);
int /*<<< orphan*/ hline(float *, float *, float *, float *, float *, float *,
                         float *, float *);
int /*<<< orphan*/ hvline(float *, float *, float *, float *, float *, float *,
                          float *, float *);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stdin;
int strlen(char *);
int /*<<< orphan*/ strncat(char *, char *, int);
int /*<<< orphan*/ vchecker1(float, float, float, float, float *, float *,
                             float *, float *);
int /*<<< orphan*/ vchecker2(float, float, float, float, float *, float *,
                             float *, float *);
void Problem2() {
  float x1, x2, x3, x4, y1, y2, y3, y4, m1, m2, b1, b2, interx, intery, first,
      second;
  float lcheckerx1, hcheckerx1, lcheckery1, hcheckery1;
  float lcheckerx2, hcheckerx2, lcheckery2, hcheckery2;
  char string[1000], temp[1000] = "";
  float x[8];
  int k = 0, i;
  printf("Problem 2: Given 4 points ((x1,y1), (x2,y2), (x3,y3), (x4,y4)), "
         "\nthe program will determine the intersection of the line segments "
         "formed by \n(x1,y1), (x2,y2) and (x3,y3), (x4,y4).\n");
  printf("Enter x1,y1,x2,y2,x3,y3,x4,y4: ");
  fgets(string, 1000, stdin);
  string[strlen(string) - 1] = '\0';
  for (i = 0; i < strlen(string); i++) {
    for (i; string[i] != ',' && i < strlen(string); i++) {
      strncat(temp, &string[i], 1);
    }
    x[k] = atof(temp);
    k++;
    memset(&temp[0], 0, sizeof(temp));
  }
  x1 = x[0];
  y1 = x[1];
  x2 = x[2];
  y2 = x[3];
  x3 = x[4];
  y3 = x[5];
  x4 = x[6];
  y4 = x[7];
  printf("The output is: ");
  if ((x2 - x1) == 0) {
    if ((x4 - x3) == 0) {
      vchecker1(x1, y1, x2, y2, &hcheckerx1, &hcheckery1, &lcheckerx1,
                &lcheckery1);
      vchecker2(x3, y3, x4, y4, &hcheckerx2, &hcheckery2, &lcheckerx2,
                &lcheckery2);
      hvline(&hcheckerx1, &hcheckery1, &lcheckerx1, &lcheckery1, &hcheckerx2,
             &hcheckery2, &lcheckerx2, &lcheckery2);
      if (hcheckerx1 == hcheckerx2) {
        if (lcheckery1 == hcheckery2) {
          printf("The lines will intersect at (%.3f, %.3f).\n", lcheckerx1,
                 lcheckery1);
        } else if ((lcheckery1 >= lcheckery2) && (lcheckery1 <= hcheckery2)) {
          printf("The lines are coinciding.\n");
        } else {
          printf("No intersection.\n");
        }
      } else {
        printf("No intersection.\n");
      }
    } else {
      vchecker1(x1, y1, x2, y2, &hcheckerx1, &hcheckery1, &lcheckerx1,
                &lcheckery1);
      checker2(x3, y3, x4, y4, &hcheckerx2, &hcheckery2, &lcheckerx2,
               &lcheckery2);
      float high1, low1;
      if (hcheckery2 < lcheckery2) {
        high1 = lcheckery2, low1 = hcheckery2;
      } else {
        high1 = hcheckery2, low1 = lcheckery2;
      }
      m2 = (y4 - y3) / (x4 - x3);
      b2 = (y3) - (m2 * x3);
      interx = hcheckerx1;
      intery = (m2 * (interx)) + (b2);
      if ((intery >= lcheckery1 && intery <= hcheckery1) &&
          (interx >= lcheckerx2 && interx <= hcheckerx2) &&
          (intery <= high1 && intery >= low1)) {
        printf("The lines will intersect at (%.3f, %.3f).\n", interx, intery);
      } else {
        printf("No intersection.\n");
      }
    }
  } else if ((x4 - x3) == 0) {
    checker1(x1, y1, x2, y2, &hcheckerx1, &hcheckery1, &lcheckerx1,
             &lcheckery1);
    vchecker2(x3, y3, x4, y4, &hcheckerx2, &hcheckery2, &lcheckerx2,
              &lcheckery2);
    float high, low;
    if (hcheckery1 < lcheckery1) {
      high = lcheckery1, low = hcheckery1;
    } else {
      high = hcheckery1, low = lcheckery1;
    }
    m1 = (y2 - y1) / (x2 - x1);
    b1 = (y1) - (m1 * x1);
    interx = hcheckerx2;
    intery = (m1 * (interx)) + (b1);
    if ((intery >= lcheckery2 && intery <= hcheckery2) &&
        (interx >= lcheckerx1 && interx <= hcheckerx1) &&
        (intery <= high && intery >= low)) {
      printf("The lines will intersect at (%.3f, %.3f).\n", interx, intery);
    } else {
      printf("No intersection.\n");
    }
  } else {
    m1 = (y2 - y1) / (x2 - x1);
    m2 = (y4 - y3) / (x4 - x3);
    b1 = (y1) - (m1 * x1);
    b2 = (y3) - (m2 * x3);
    checker1(x1, y1, x2, y2, &hcheckerx1, &hcheckery1, &lcheckerx1,
             &lcheckery1);
    checker2(x3, y3, x4, y4, &hcheckerx2, &hcheckery2, &lcheckerx2,
             &lcheckery2);
    hline(&hcheckerx1, &hcheckery1, &lcheckerx1, &lcheckery1, &hcheckerx2,
          &hcheckery2, &lcheckerx2, &lcheckery2);
    if (m1 == m2) {
      if (b1 == b2) {
        if ((lcheckerx1 == hcheckerx1) && (lcheckery1 == hcheckery2)) {
          printf("The lines will intersect at (%.3f, %.3f).\n", lcheckerx1,
                 lcheckery1);
        } else if ((lcheckerx1 >= lcheckerx2) && (lcheckerx1 <= hcheckerx2)) {
          printf("The lines are coinciding.\n");
        } else {
          printf("No intersection.\n");
        }
      } else {
        printf("No intersection.\n");
      }
    } else {
      interx = (b2 - b1) / (m1 - m2);
      intery = (m1 * (interx)) + (b1);
      float high, low, high1, low1;
      if (hcheckery1 < lcheckery1) {
        high = lcheckery1, low = hcheckery1;
      } else {
        high = hcheckery1, low = lcheckery1;
      }
      if (hcheckery2 < lcheckery2) {
        high1 = lcheckery2, low1 = hcheckery2;
      } else {
        high1 = hcheckery2, low1 = lcheckery2;
      }
      if (x1 > x2) {
        first = x1;
        second = x2;
      } else {
        first = x2;
        second = x1;
      }
      if (((interx <= hcheckerx1) && (interx >= lcheckerx1) &&
           (interx <= hcheckerx2) && (interx >= lcheckerx2)) &&
          ((intery <= high) && (intery >= low) && (intery <= high1) &&
           (intery >= low1))) {
        printf("The lines will intersect at (%.3f,%.3f).\n", interx, intery);
      } else {
        printf("No intersection.\n");
      }
    }
  }
}


x86 assembly (clang, -O0):
<Problem2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8b0,%rsp
lea    -0x840(%rbp),%rdi
xor    %esi,%esi
mov    $0x3e8,%edx
call   1080 <memset@plt>
movl   $0x0,-0x864(%rbp)
lea    0xe11(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xeb8(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    -0x450(%rbp),%rdi
mov    0x2dd6(%rip),%rax
mov    (%rax),%edx
mov    $0x3e8,%esi
call   10b0 <fgets@plt>
lea    -0x450(%rbp),%rdi
call   1060 <strlen@plt>
sub    $0x1,%eax
cltq
movb   $0x0,-0x450(%rbp,%rax,1)
movl   $0x0,-0x868(%rbp)
mov    -0x868(%rbp),%eax
mov    %eax,-0x88c(%rbp)
lea    -0x450(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,%ecx
mov    -0x88c(%rbp),%eax
cmp    %ecx,%eax
jge    134f <Problem2+0x18f>
movslq -0x868(%rbp),%rax
movsbl -0x450(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x88d(%rbp)
je     12b4 <Problem2+0xf4>
mov    -0x868(%rbp),%eax
mov    %eax,-0x894(%rbp)
lea    -0x450(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,%ecx
mov    -0x894(%rbp),%eax
cmp    %ecx,%eax
setl   %al
mov    %al,-0x88d(%rbp)
mov    -0x88d(%rbp),%al
test   $0x1,%al
jne    12c7 <Problem2+0x107>
jmp    12fd <Problem2+0x13d>
lea    -0x840(%rbp),%rdi
movslq -0x868(%rbp),%rax
lea    -0x450(%rbp),%rsi
add    %rax,%rsi
mov    $0x1,%edx
call   1090 <strncat@plt>
mov    -0x868(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x868(%rbp)
jmp    1269 <Problem2+0xa9>
lea    -0x840(%rbp),%rdi
call   1040 <atof@plt>
movslq -0x864(%rbp),%rax
movss  %xmm0,-0x860(%rbp,%rax,4)
ff ff
mov    -0x864(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x864(%rbp)
lea    -0x840(%rbp),%rdi
xor    %esi,%esi
mov    $0x3e8,%edx
call   1080 <memset@plt>
mov    -0x868(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x868(%rbp)
jmp    1241 <Problem2+0x81>
movss  -0x860(%rbp),%xmm0
ff
movss  %xmm0,-0x4(%rbp)
movss  -0x85c(%rbp),%xmm0
ff
movss  %xmm0,-0x14(%rbp)
movss  -0x858(%rbp),%xmm0
ff
movss  %xmm0,-0x8(%rbp)
movss  -0x854(%rbp),%xmm0
ff
movss  %xmm0,-0x18(%rbp)
movss  -0x850(%rbp),%xmm0
ff
movss  %xmm0,-0xc(%rbp)
movss  -0x84c(%rbp),%xmm0
ff
movss  %xmm0,-0x1c(%rbp)
movss  -0x848(%rbp),%xmm0
ff
movss  %xmm0,-0x10(%rbp)
movss  -0x844(%rbp),%xmm0
ff
movss  %xmm0,-0x20(%rbp)
lea    0xd17(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movss  -0x8(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    16df <Problem2+0x51f>
jp     16df <Problem2+0x51f>
movss  -0x10(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    152c <Problem2+0x36c>
jp     152c <Problem2+0x36c>
movss  -0x4(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0x18(%rbp),%xmm3
lea    -0x48(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
call   10a0 <vchecker1@plt>
movss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
lea    -0x58(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x54(%rbp),%rdx
lea    -0x5c(%rbp),%rcx
call   1030 <vchecker2@plt>
lea    -0x48(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
lea    -0x58(%rbp),%r8
lea    -0x60(%rbp),%r9
lea    -0x54(%rbp),%r10
lea    -0x5c(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   10d0 <hvline@plt>
movss  -0x48(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jne    1519 <Problem2+0x359>
jp     1519 <Problem2+0x359>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jne    14cc <Problem2+0x30c>
jp     14cc <Problem2+0x30c>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc25(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    1514 <Problem2+0x354>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
jb     1501 <Problem2+0x341>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1501 <Problem2+0x341>
lea    0xc1b(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    150f <Problem2+0x34f>
lea    0xc23(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1514 <Problem2+0x354>
jmp    1527 <Problem2+0x367>
lea    0xc0b(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    16da <Problem2+0x51a>
movss  -0x4(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0x18(%rbp),%xmm3
lea    -0x48(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
call   10a0 <vchecker1@plt>
movss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
lea    -0x58(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x54(%rbp),%rdx
lea    -0x5c(%rbp),%rcx
call   10c0 <checker2@plt>
movss  -0x60(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    15b0 <Problem2+0x3f0>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x86c(%rbp)
ff
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x870(%rbp)
ff
jmp    15ca <Problem2+0x40a>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x86c(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x870(%rbp)
ff
movss  -0x20(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  -0x10(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jb     16c7 <Problem2+0x507>
movss  -0x38(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     16c7 <Problem2+0x507>
movss  -0x34(%rbp),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     16c7 <Problem2+0x507>
movss  -0x34(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     16c7 <Problem2+0x507>
movss  -0x38(%rbp),%xmm1
movss  -0x86c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     16c7 <Problem2+0x507>
movss  -0x38(%rbp),%xmm0
ucomiss -0x870(%rbp),%xmm0
jb     16c7 <Problem2+0x507>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xa2a(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    16d5 <Problem2+0x515>
lea    0xa5d(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    16da <Problem2+0x51a>
jmp    1c71 <Problem2+0xab1>
movss  -0x10(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    18a9 <Problem2+0x6e9>
jp     18a9 <Problem2+0x6e9>
movss  -0x4(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0x18(%rbp),%xmm3
lea    -0x48(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
call   1050 <checker1@plt>
movss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
lea    -0x58(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x54(%rbp),%rdx
lea    -0x5c(%rbp),%rcx
call   1030 <vchecker2@plt>
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    177f <Problem2+0x5bf>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x874(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x878(%rbp)
ff
jmp    1799 <Problem2+0x5d9>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x874(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x878(%rbp)
ff
movss  -0x18(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
movss  -0x8(%rbp),%xmm1
subss  -0x4(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x4(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
jb     1896 <Problem2+0x6d6>
movss  -0x38(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1896 <Problem2+0x6d6>
movss  -0x34(%rbp),%xmm0
ucomiss -0x44(%rbp),%xmm0
jb     1896 <Problem2+0x6d6>
movss  -0x34(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1896 <Problem2+0x6d6>
movss  -0x38(%rbp),%xmm1
movss  -0x874(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     1896 <Problem2+0x6d6>
movss  -0x38(%rbp),%xmm0
ucomiss -0x878(%rbp),%xmm0
jb     1896 <Problem2+0x6d6>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x85b(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    18a4 <Problem2+0x6e4>
lea    0x88e(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1c6c <Problem2+0xaac>
movss  -0x18(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
movss  -0x8(%rbp),%xmm1
subss  -0x4(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  -0x10(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x4(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x4(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0x18(%rbp),%xmm3
lea    -0x48(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
call   1050 <checker1@plt>
movss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
lea    -0x58(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x54(%rbp),%rdx
lea    -0x5c(%rbp),%rcx
call   10c0 <checker2@plt>
lea    -0x48(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
lea    -0x58(%rbp),%r8
lea    -0x60(%rbp),%r9
lea    -0x54(%rbp),%r10
lea    -0x5c(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   10e0 <hline@plt>
movss  -0x24(%rbp),%xmm0
ucomiss -0x28(%rbp),%xmm0
jne    1a8e <Problem2+0x8ce>
jp     1a8e <Problem2+0x8ce>
movss  -0x2c(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jne    1a7b <Problem2+0x8bb>
jp     1a7b <Problem2+0x8bb>
movss  -0x44(%rbp),%xmm0
ucomiss -0x48(%rbp),%xmm0
jne    1a2e <Problem2+0x86e>
jp     1a2e <Problem2+0x86e>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jne    1a2e <Problem2+0x86e>
jp     1a2e <Problem2+0x86e>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x6c3(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    1a76 <Problem2+0x8b6>
movss  -0x44(%rbp),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     1a63 <Problem2+0x8a3>
movss  -0x44(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1a63 <Problem2+0x8a3>
lea    0x6b9(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1a71 <Problem2+0x8b1>
lea    0x6c1(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1a76 <Problem2+0x8b6>
jmp    1a89 <Problem2+0x8c9>
lea    0x6a9(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1c67 <Problem2+0xaa7>
movss  -0x30(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm1
subss  -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1af9 <Problem2+0x939>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x87c(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x880(%rbp)
ff
jmp    1b13 <Problem2+0x953>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x87c(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x880(%rbp)
ff
movss  -0x60(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1b45 <Problem2+0x985>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x884(%rbp)
ff
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x888(%rbp)
ff
jmp    1b5f <Problem2+0x99f>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x884(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x888(%rbp)
ff
movss  -0x4(%rbp),%xmm0
ucomiss -0x8(%rbp),%xmm0
jbe    1b87 <Problem2+0x9c7>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    1b9b <Problem2+0x9db>
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x34(%rbp),%xmm0
ucomiss -0x44(%rbp),%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x34(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x34(%rbp),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x38(%rbp),%xmm1
movss  -0x87c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x38(%rbp),%xmm0
ucomiss -0x880(%rbp),%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x38(%rbp),%xmm1
movss  -0x884(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x38(%rbp),%xmm0
ucomiss -0x888(%rbp),%xmm0
jb     1c54 <Problem2+0xa94>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x4f5(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    1c62 <Problem2+0xaa2>
lea    0x4d0(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1c67 <Problem2+0xaa7>
jmp    1c6c <Problem2+0xaac>
jmp    1c71 <Problem2+0xab1>
add    $0x8b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Problem2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x8b8,%rsp
lea    0x4d0(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x3e8,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0xe8b(%rip),%rdi
call   1030 <puts@plt>
lea    0xdfa(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x2dd0(%rip),%rax
mov    (%rax),%edx
lea    0xe0(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x3e8,%esi
call   10c0 <fgets@plt>
mov    %rbp,%rdi
call   1070 <strlen@plt>
cltq
movb   $0x0,-0x1(%rax,%rbp,1)
mov    %rbp,%rdi
call   1070 <strlen@plt>
test   %eax,%eax
jle    1367 <Problem2+0x197>
lea    0x4d0(%rsp),%r15
lea    0xe0(%rsp),%r14
xor    %r12d,%r12d
jmp    12a4 <Problem2+0xd4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rbx
mov    %r15,%rdi
call   1050 <atof@plt>
movss  %xmm0,0x70(%rsp,%r12,4)
add    $0x1,%r12
mov    %r15,%rdi
xor    %esi,%esi
mov    $0x3e8,%edx
call   1090 <memset@plt>
add    $0x1,%ebx
mov    %r14,%rdi
call   1070 <strlen@plt>
cmp    %eax,%ebx
jge    12fd <Problem2+0x12d>
movslq %ebx,%rbp
cmpb   $0x2c,0xe0(%rsp,%rbp,1)
2c
je     1273 <Problem2+0xa3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
call   1070 <strlen@plt>
cltq
cmp    %rax,%rbp
jge    1270 <Problem2+0xa0>
lea    (%rsp,%rbp,1),%rsi
add    $0xe0,%rsi
mov    %r15,%rdi
mov    $0x1,%edx
call   10a0 <strncat@plt>
lea    0x1(%rbp),%rbx
cmpb   $0x2c,0xe1(%rsp,%rbp,1)
2c
mov    %rbx,%rbp
jne    12c0 <Problem2+0xf0>
jmp    1273 <Problem2+0xa3>
movaps 0x70(%rsp),%xmm0
movups 0x74(%rsp),%xmm1
movups 0x78(%rsp),%xmm2
movups 0x7c(%rsp),%xmm3
movss  0x8c(%rsp),%xmm4
movlhps %xmm3,%xmm4
shufps $0xe2,%xmm3,%xmm4
movaps %xmm4,0x20(%rsp)
movss  0x84(%rsp),%xmm3
movlhps %xmm1,%xmm3
shufps $0xe2,%xmm1,%xmm3
movaps %xmm3,0x30(%rsp)
movss  0x88(%rsp),%xmm1
movlhps %xmm2,%xmm1
shufps $0xe2,%xmm2,%xmm1
movaps %xmm1,0x60(%rsp)
movss  0x80(%rsp),%xmm1
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
jmp    1367 <Problem2+0x197>
lea    0xcb6(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
movaps 0x60(%rsp),%xmm2
movaps %xmm2,%xmm4
movaps 0x50(%rsp),%xmm0
subps  %xmm0,%xmm4
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm4
jne    148f <Problem2+0x2bf>
jp     148f <Problem2+0x2bf>
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%rcx
movaps %xmm1,0x40(%rsp)
movaps 0x30(%rsp),%xmm1
movaps 0x20(%rsp),%xmm3
call   10b0 <vchecker1@plt>
movaps 0x40(%rsp),%xmm4
ucomiss 0xc2e(%rip),%xmm4
jne    1581 <Problem2+0x3b1>
jp     1581 <Problem2+0x3b1>
movaps 0x20(%rsp),%xmm3
shufps $0x55,%xmm3,%xmm3
movaps 0x30(%rsp),%xmm1
shufps $0x55,%xmm1,%xmm1
movaps 0x60(%rsp),%xmm2
shufps $0x55,%xmm2,%xmm2
movaps 0x50(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
lea    0x4(%rsp),%r12
mov    %rsp,%r14
lea    0x1c(%rsp),%r15
lea    0x14(%rsp),%rbx
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
call   1040 <vchecker2@plt>
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%rcx
mov    %r12,%r8
mov    %r14,%r9
push   %rbx
push   %r15
call   10e0 <hvline@plt>
add    $0x10,%rsp
movss  0xc(%rsp),%xmm0
ucomiss 0x4(%rsp),%xmm0
jne    1896 <Problem2+0x6c6>
jp     1896 <Problem2+0x6c6>
movss  0x8(%rsp),%xmm1
movss  (%rsp),%xmm0
ucomiss %xmm0,%xmm1
jne    17d3 <Problem2+0x603>
jp     17d3 <Problem2+0x603>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
jmp    166a <Problem2+0x49a>
ucomiss %xmm3,%xmm1
movaps 0x20(%rsp),%xmm3
movaps 0x30(%rsp),%xmm1
movaps %xmm2,0x60(%rsp)
jne    167d <Problem2+0x4ad>
jp     167d <Problem2+0x4ad>
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%rcx
movaps %xmm1,0x30(%rsp)
movaps %xmm4,0x40(%rsp)
call   1060 <checker1@plt>
movaps 0x20(%rsp),%xmm3
shufps $0x55,%xmm3,%xmm3
movaps 0x30(%rsp),%xmm1
shufps $0x55,%xmm1,%xmm1
movaps 0x60(%rsp),%xmm2
shufps $0x55,%xmm2,%xmm2
movaps 0x50(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
lea    0x4(%rsp),%rdi
mov    %rsp,%rsi
lea    0x1c(%rsp),%rdx
lea    0x14(%rsp),%rcx
call   1040 <vchecker2@plt>
movaps 0x20(%rsp),%xmm4
movaps 0x30(%rsp),%xmm0
subss  %xmm0,%xmm4
divss  0x40(%rsp),%xmm4
movaps 0x50(%rsp),%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm0
movaps %xmm0,%xmm1
movss  0x4(%rsp),%xmm0
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
ucomiss 0x14(%rsp),%xmm4
jb     1896 <Problem2+0x6c6>
movss  (%rsp),%xmm1
ucomiss %xmm4,%xmm1
jb     1896 <Problem2+0x6c6>
ucomiss 0x10(%rsp),%xmm0
jb     1896 <Problem2+0x6c6>
movss  0xc(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jb     1896 <Problem2+0x6c6>
movss  0x18(%rsp),%xmm1
movss  0x8(%rsp),%xmm2
jmp    1642 <Problem2+0x472>
movaps 0x20(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,%xmm3
movaps %xmm0,0x20(%rsp)
movaps 0x30(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,%xmm1
movaps %xmm0,0x30(%rsp)
movaps 0x60(%rsp),%xmm2
shufps $0x55,%xmm2,%xmm2
movaps 0x50(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
lea    0x4(%rsp),%rdi
mov    %rsp,%rsi
lea    0x1c(%rsp),%rdx
lea    0x14(%rsp),%rcx
call   10d0 <checker2@plt>
movaps 0x20(%rsp),%xmm4
movaps 0x30(%rsp),%xmm0
subss  %xmm0,%xmm4
divss  0x40(%rsp),%xmm4
movaps 0x50(%rsp),%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm0
movaps %xmm0,%xmm1
movss  0xc(%rsp),%xmm0
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
ucomiss 0x8(%rsp),%xmm4
jb     1896 <Problem2+0x6c6>
movss  0x18(%rsp),%xmm1
ucomiss %xmm4,%xmm1
jb     1896 <Problem2+0x6c6>
ucomiss 0x1c(%rsp),%xmm0
jb     1896 <Problem2+0x6c6>
movss  0x4(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jb     1896 <Problem2+0x6c6>
movss  (%rsp),%xmm1
movss  0x14(%rsp),%xmm2
movaps %xmm2,%xmm3
maxss  %xmm1,%xmm3
ucomiss %xmm4,%xmm3
jb     1896 <Problem2+0x6c6>
minss  %xmm2,%xmm1
ucomiss %xmm1,%xmm4
jb     1896 <Problem2+0x6c6>
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
lea    0x9c3(%rip),%rdi
mov    $0x2,%al
call   1080 <printf@plt>
jmp    18a2 <Problem2+0x6d2>
movaps %xmm3,%xmm6
subps  %xmm1,%xmm6
divps  %xmm4,%xmm6
movaps %xmm6,0xd0(%rsp)
movaps %xmm6,%xmm4
mulss  %xmm0,%xmm4
movaps %xmm1,%xmm5
subss  %xmm4,%xmm5
movaps %xmm5,0x40(%rsp)
shufps $0x55,%xmm6,%xmm6
movaps %xmm6,0xc0(%rsp)
movaps %xmm1,%xmm5
shufps $0x55,%xmm1,%xmm5
movaps %xmm5,0xa0(%rsp)
movaps %xmm0,%xmm4
shufps $0x55,%xmm0,%xmm4
movaps %xmm4,0xb0(%rsp)
mulss  %xmm6,%xmm4
subss  %xmm4,%xmm5
movaps %xmm5,0x90(%rsp)
lea    0xc(%rsp),%r13
lea    0x18(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%r12
mov    %r13,%rdi
mov    %r12,%rcx
movaps %xmm3,0x20(%rsp)
call   1060 <checker1@plt>
movaps 0x20(%rsp),%xmm3
shufps $0x55,%xmm3,%xmm3
movaps 0x60(%rsp),%xmm2
shufps $0x55,%xmm2,%xmm2
lea    0x4(%rsp),%rbx
mov    %rsp,%rbp
lea    0x1c(%rsp),%r14
lea    0x14(%rsp),%r15
movaps 0xb0(%rsp),%xmm0
movaps 0xa0(%rsp),%xmm1
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r15,%rcx
call   10d0 <checker2@plt>
mov    %r13,%rdi
lea    0x18(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    %r12,%rcx
mov    %rbx,%r8
mov    %rbp,%r9
push   %r15
push   %r14
call   10f0 <hline@plt>
movaps 0xd0(%rsp),%xmm2
movaps 0xe0(%rsp),%xmm3
add    $0x10,%rsp
ucomiss %xmm2,%xmm3
jne    17f3 <Problem2+0x623>
jp     17f3 <Problem2+0x623>
movaps 0x40(%rsp),%xmm0
ucomiss 0x90(%rsp),%xmm0
jne    1896 <Problem2+0x6c6>
jp     1896 <Problem2+0x6c6>
movss  0x10(%rsp),%xmm0
ucomiss 0xc(%rsp),%xmm0
jne    17b8 <Problem2+0x5e8>
jp     17b8 <Problem2+0x5e8>
movss  0x8(%rsp),%xmm1
ucomiss (%rsp),%xmm1
jne    17b8 <Problem2+0x5e8>
jnp    1482 <Problem2+0x2b2>
ucomiss 0x1c(%rsp),%xmm0
jb     1896 <Problem2+0x6c6>
movss  0x4(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jae    17e7 <Problem2+0x617>
jmp    1896 <Problem2+0x6c6>
ucomiss 0x14(%rsp),%xmm1
jb     1896 <Problem2+0x6c6>
ucomiss %xmm1,%xmm0
jb     1896 <Problem2+0x6c6>
lea    0x960(%rip),%rdi
jmp    189d <Problem2+0x6cd>
movaps 0x40(%rsp),%xmm1
movaps 0x90(%rsp),%xmm4
subss  %xmm1,%xmm4
movaps %xmm3,%xmm0
subss  %xmm2,%xmm0
divss  %xmm0,%xmm4
movss  0xc(%rsp),%xmm0
ucomiss %xmm4,%xmm0
jb     1896 <Problem2+0x6c6>
ucomiss 0x10(%rsp),%xmm4
jb     1896 <Problem2+0x6c6>
movss  0x4(%rsp),%xmm0
ucomiss %xmm4,%xmm0
jb     1896 <Problem2+0x6c6>
ucomiss 0x1c(%rsp),%xmm4
jb     1896 <Problem2+0x6c6>
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  0x18(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps %xmm1,%xmm2
maxss  %xmm0,%xmm2
ucomiss %xmm3,%xmm2
jb     1896 <Problem2+0x6c6>
minss  %xmm1,%xmm0
ucomiss %xmm0,%xmm3
jb     1896 <Problem2+0x6c6>
movss  (%rsp),%xmm0
movss  0x14(%rsp),%xmm1
movaps %xmm1,%xmm2
maxss  %xmm0,%xmm2
ucomiss %xmm3,%xmm2
jb     1896 <Problem2+0x6c6>
minss  %xmm1,%xmm0
ucomiss %xmm0,%xmm3
jb     1896 <Problem2+0x6c6>
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
lea    0x7ce(%rip),%rdi
jmp    1671 <Problem2+0x4a1>
lea    0x8a0(%rip),%rdi
call   1030 <puts@plt>
add    $0x8b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [181 x i8] c"Problem 2: Given 4 points ((x1,y1), (x2,y2), (x3,y3), (x4,y4)), \0Athe program will determine the intersection of the line segments formed by \0A(x1,y1), (x2,y2) and (x3,y3), (x4,y4).\0A\00"
@.str.1 = [32 x i8] c"Enter x1,y1,x2,y2,x3,y3,x4,y4: \00"
@stdin = global i32 0
@.str.2 = [16 x i8] c"The output is: \00"
@.str.3 = [43 x i8] c"The lines will intersect at (%.3f, %.3f).\0A\00"
@.str.4 = [27 x i8] c"The lines are coinciding.\0A\00"
@.str.5 = [18 x i8] c"No intersection.\0A\00"
@.str.6 = [42 x i8] c"The lines will intersect at (%.3f,%.3f).\0A\00"
define void @Problem2() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca [1000 x i8]
%26 = alloca [1000 x i8]
%27 = alloca [8 x float]
%28 = alloca i32
%29 = alloca i32
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = bitcast [1000 x i8]* %26 to i8*
store i32 0, i32* %28
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([181 x i8], [181 x i8]* @.str, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0))
%41 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 0
%42 = load i32, i32* @stdin
%43 = call i32 @fgets(i8* %41, i32 1000, i32 %42)
%44 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 0
%45 = call i32 @strlen(i8* %44)
%46 = sub nsw i32 %45, 1
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 %47
store i8 0, i8* %48
store i32 0, i32* %29
br label %49
49: ; preds = %89, %0
%50 = load i32, i32* %29
%51 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 0
%52 = call i32 @strlen(i8* %51)
%53 = icmp slt i32 %50, %52
br i1 %53, label %54, label %92
54: ; preds = %49
%55 = load i32, i32* %29
br label %56
56: ; preds = %76, %54
%57 = load i32, i32* %29
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 %58
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = icmp ne i32 %61, 44
br i1 %62, label %63, label %68
63: ; preds = %56
%64 = load i32, i32* %29
%65 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 0
%66 = call i32 @strlen(i8* %65)
%67 = icmp slt i32 %64, %66
br label %68
68: ; preds = %63, %56
%69 = phi i1 [ false, %56 ], [ %67, %63 ]
br i1 %69, label %70, label %79
70: ; preds = %68
%71 = getelementptr inbounds [1000 x i8], [1000 x i8]* %26, i64 0, i64 0
%72 = load i32, i32* %29
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [1000 x i8], [1000 x i8]* %25, i64 0, i64 %73
%75 = call i32 @strncat(i8* %71, i8* %74, i32 1)
br label %76
76: ; preds = %70
%77 = load i32, i32* %29
%78 = add nsw i32 %77, 1
store i32 %78, i32* %29
br label %56
79: ; preds = %68
%80 = getelementptr inbounds [1000 x i8], [1000 x i8]* %26, i64 0, i64 0
%81 = call float @atof(i8* %80)
%82 = load i32, i32* %28
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 %83
store float %81, float* %84
%85 = load i32, i32* %28
%86 = add nsw i32 %85, 1
store i32 %86, i32* %28
%87 = getelementptr inbounds [1000 x i8], [1000 x i8]* %26, i64 0, i64 0
%88 = call i32 @memset(i8* %87, i32 0, i32 1000)
br label %89
89: ; preds = %79
%90 = load i32, i32* %29
%91 = add nsw i32 %90, 1
store i32 %91, i32* %29
br label %49
92: ; preds = %49
%93 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 0
%94 = load float, float* %93
store float %94, float* %1
%95 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 1
%96 = load float, float* %95
store float %96, float* %5
%97 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 2
%98 = load float, float* %97
store float %98, float* %2
%99 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 3
%100 = load float, float* %99
store float %100, float* %6
%101 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 4
%102 = load float, float* %101
store float %102, float* %3
%103 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 5
%104 = load float, float* %103
store float %104, float* %7
%105 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 6
%106 = load float, float* %105
store float %106, float* %4
%107 = getelementptr inbounds [8 x float], [8 x float]* %27, i64 0, i64 7
%108 = load float, float* %107
store float %108, float* %8
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0))
%110 = load float, float* %2
%111 = load float, float* %1
%112 = fsub float %110, %111
%113 = fcmp oeq float %112, 0.000000e+00
br i1 %113, label %114, label %232
114: ; preds = %92
%115 = load float, float* %4
%116 = load float, float* %3
%117 = fsub float %115, %116
%118 = fcmp oeq float %117, 0.000000e+00
br i1 %118, label %119, label %161
119: ; preds = %114
%120 = load float, float* %1
%121 = load float, float* %5
%122 = load float, float* %2
%123 = load float, float* %6
%124 = call i32 @vchecker1(float %120, float %121, float %122, float %123, float* %18, float* %20, float* %17, float* %19)
%125 = load float, float* %3
%126 = load float, float* %7
%127 = load float, float* %4
%128 = load float, float* %8
%129 = call i32 @vchecker2(float %125, float %126, float %127, float %128, float* %22, float* %24, float* %21, float* %23)
%130 = call i32 @hvline(float* %18, float* %20, float* %17, float* %19, float* %22, float* %24, float* %21, float* %23)
%131 = load float, float* %18
%132 = load float, float* %22
%133 = fcmp oeq float %131, %132
br i1 %133, label %134, label %158
134: ; preds = %119
%135 = load float, float* %19
%136 = load float, float* %24
%137 = fcmp oeq float %135, %136
br i1 %137, label %138, label %144
138: ; preds = %134
%139 = load float, float* %17
%140 = fpext float %139 to double
%141 = load float, float* %19
%142 = fpext float %141 to double
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %140, double %142)
br label %157
144: ; preds = %134
%145 = load float, float* %19
%146 = load float, float* %23
%147 = fcmp oge float %145, %146
br i1 %147, label %148, label %154
148: ; preds = %144
%149 = load float, float* %19
%150 = load float, float* %24
%151 = fcmp ole float %149, %150
br i1 %151, label %152, label %154
152: ; preds = %148
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.4, i64 0, i64 0))
br label %156
154: ; preds = %148, %144
%155 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %156
156: ; preds = %154, %152
br label %157
157: ; preds = %156, %138
br label %160
158: ; preds = %119
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %160
160: ; preds = %158, %157
br label %231
161: ; preds = %114
%162 = load float, float* %1
%163 = load float, float* %5
%164 = load float, float* %2
%165 = load float, float* %6
%166 = call i32 @vchecker1(float %162, float %163, float %164, float %165, float* %18, float* %20, float* %17, float* %19)
%167 = load float, float* %3
%168 = load float, float* %7
%169 = load float, float* %4
%170 = load float, float* %8
%171 = call i32 @checker2(float %167, float %168, float %169, float %170, float* %22, float* %24, float* %21, float* %23)
%172 = load float, float* %24
%173 = load float, float* %23
%174 = fcmp olt float %172, %173
br i1 %174, label %175, label %178
175: ; preds = %161
%176 = load float, float* %23
store float %176, float* %30
%177 = load float, float* %24
store float %177, float* %31
br label %181
178: ; preds = %161
%179 = load float, float* %24
store float %179, float* %30
%180 = load float, float* %23
store float %180, float* %31
br label %181
181: ; preds = %178, %175
%182 = load float, float* %8
%183 = load float, float* %7
%184 = fsub float %182, %183
%185 = load float, float* %4
%186 = load float, float* %3
%187 = fsub float %185, %186
%188 = fdiv float %184, %187
store float %188, float* %10
%189 = load float, float* %7
%190 = load float, float* %10
%191 = load float, float* %3
%192 = fneg float %190
%193 = call float @llvm.fmuladd.f32(float %192, float %191, float %189)
store float %193, float* %12
%194 = load float, float* %18
store float %194, float* %13
%195 = load float, float* %10
%196 = load float, float* %13
%197 = load float, float* %12
%198 = call float @llvm.fmuladd.f32(float %195, float %196, float %197)
store float %198, float* %14
%199 = load float, float* %14
%200 = load float, float* %19
%201 = fcmp oge float %199, %200
br i1 %201, label %202, label %228
202: ; preds = %181
%203 = load float, float* %14
%204 = load float, float* %20
%205 = fcmp ole float %203, %204
br i1 %205, label %206, label %228
206: ; preds = %202
%207 = load float, float* %13
%208 = load float, float* %21
%209 = fcmp oge float %207, %208
br i1 %209, label %210, label %228
210: ; preds = %206
%211 = load float, float* %13
%212 = load float, float* %22
%213 = fcmp ole float %211, %212
br i1 %213, label %214, label %228
214: ; preds = %210
%215 = load float, float* %14
%216 = load float, float* %30
%217 = fcmp ole float %215, %216
br i1 %217, label %218, label %228
218: ; preds = %214
%219 = load float, float* %14
%220 = load float, float* %31
%221 = fcmp oge float %219, %220
br i1 %221, label %222, label %228
222: ; preds = %218
%223 = load float, float* %13
%224 = fpext float %223 to double
%225 = load float, float* %14
%226 = fpext float %225 to double
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %224, double %226)
br label %230
228: ; preds = %218, %214, %210, %206, %202, %181
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %230
230: ; preds = %228, %222
br label %231
231: ; preds = %230, %160
br label %465
232: ; preds = %92
%233 = load float, float* %4
%234 = load float, float* %3
%235 = fsub float %233, %234
%236 = fcmp oeq float %235, 0.000000e+00
br i1 %236, label %237, label %307
237: ; preds = %232
%238 = load float, float* %1
%239 = load float, float* %5
%240 = load float, float* %2
%241 = load float, float* %6
%242 = call i32 @checker1(float %238, float %239, float %240, float %241, float* %18, float* %20, float* %17, float* %19)
%243 = load float, float* %3
%244 = load float, float* %7
%245 = load float, float* %4
%246 = load float, float* %8
%247 = call i32 @vchecker2(float %243, float %244, float %245, float %246, float* %22, float* %24, float* %21, float* %23)
%248 = load float, float* %20
%249 = load float, float* %19
%250 = fcmp olt float %248, %249
br i1 %250, label %251, label %254
251: ; preds = %237
%252 = load float, float* %19
store float %252, float* %32
%253 = load float, float* %20
store float %253, float* %33
br label %257
254: ; preds = %237
%255 = load float, float* %20
store float %255, float* %32
%256 = load float, float* %19
store float %256, float* %33
br label %257
257: ; preds = %254, %251
%258 = load float, float* %6
%259 = load float, float* %5
%260 = fsub float %258, %259
%261 = load float, float* %2
%262 = load float, float* %1
%263 = fsub float %261, %262
%264 = fdiv float %260, %263
store float %264, float* %9
%265 = load float, float* %5
%266 = load float, float* %9
%267 = load float, float* %1
%268 = fneg float %266
%269 = call float @llvm.fmuladd.f32(float %268, float %267, float %265)
store float %269, float* %11
%270 = load float, float* %22
store float %270, float* %13
%271 = load float, float* %9
%272 = load float, float* %13
%273 = load float, float* %11
%274 = call float @llvm.fmuladd.f32(float %271, float %272, float %273)
store float %274, float* %14
%275 = load float, float* %14
%276 = load float, float* %23
%277 = fcmp oge float %275, %276
br i1 %277, label %278, label %304
278: ; preds = %257
%279 = load float, float* %14
%280 = load float, float* %24
%281 = fcmp ole float %279, %280
br i1 %281, label %282, label %304
282: ; preds = %278
%283 = load float, float* %13
%284 = load float, float* %17
%285 = fcmp oge float %283, %284
br i1 %285, label %286, label %304
286: ; preds = %282
%287 = load float, float* %13
%288 = load float, float* %18
%289 = fcmp ole float %287, %288
br i1 %289, label %290, label %304
290: ; preds = %286
%291 = load float, float* %14
%292 = load float, float* %32
%293 = fcmp ole float %291, %292
br i1 %293, label %294, label %304
294: ; preds = %290
%295 = load float, float* %14
%296 = load float, float* %33
%297 = fcmp oge float %295, %296
br i1 %297, label %298, label %304
298: ; preds = %294
%299 = load float, float* %13
%300 = fpext float %299 to double
%301 = load float, float* %14
%302 = fpext float %301 to double
%303 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %300, double %302)
br label %306
304: ; preds = %294, %290, %286, %282, %278, %257
%305 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %306
306: ; preds = %304, %298
br label %464
307: ; preds = %232
%308 = load float, float* %6
%309 = load float, float* %5
%310 = fsub float %308, %309
%311 = load float, float* %2
%312 = load float, float* %1
%313 = fsub float %311, %312
%314 = fdiv float %310, %313
store float %314, float* %9
%315 = load float, float* %8
%316 = load float, float* %7
%317 = fsub float %315, %316
%318 = load float, float* %4
%319 = load float, float* %3
%320 = fsub float %318, %319
%321 = fdiv float %317, %320
store float %321, float* %10
%322 = load float, float* %5
%323 = load float, float* %9
%324 = load float, float* %1
%325 = fneg float %323
%326 = call float @llvm.fmuladd.f32(float %325, float %324, float %322)
store float %326, float* %11
%327 = load float, float* %7
%328 = load float, float* %10
%329 = load float, float* %3
%330 = fneg float %328
%331 = call float @llvm.fmuladd.f32(float %330, float %329, float %327)
store float %331, float* %12
%332 = load float, float* %1
%333 = load float, float* %5
%334 = load float, float* %2
%335 = load float, float* %6
%336 = call i32 @checker1(float %332, float %333, float %334, float %335, float* %18, float* %20, float* %17, float* %19)
%337 = load float, float* %3
%338 = load float, float* %7
%339 = load float, float* %4
%340 = load float, float* %8
%341 = call i32 @checker2(float %337, float %338, float %339, float %340, float* %22, float* %24, float* %21, float* %23)
%342 = call i32 @hline(float* %18, float* %20, float* %17, float* %19, float* %22, float* %24, float* %21, float* %23)
%343 = load float, float* %9
%344 = load float, float* %10
%345 = fcmp oeq float %343, %344
br i1 %345, label %346, label %381
346: ; preds = %307
%347 = load float, float* %11
%348 = load float, float* %12
%349 = fcmp oeq float %347, %348
br i1 %349, label %350, label %378
350: ; preds = %346
%351 = load float, float* %17
%352 = load float, float* %18
%353 = fcmp oeq float %351, %352
br i1 %353, label %354, label %364
354: ; preds = %350
%355 = load float, float* %19
%356 = load float, float* %24
%357 = fcmp oeq float %355, %356
br i1 %357, label %358, label %364
358: ; preds = %354
%359 = load float, float* %17
%360 = fpext float %359 to double
%361 = load float, float* %19
%362 = fpext float %361 to double
%363 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %360, double %362)
br label %377
364: ; preds = %354, %350
%365 = load float, float* %17
%366 = load float, float* %21
%367 = fcmp oge float %365, %366
br i1 %367, label %368, label %374
368: ; preds = %364
%369 = load float, float* %17
%370 = load float, float* %22
%371 = fcmp ole float %369, %370
br i1 %371, label %372, label %374
372: ; preds = %368
%373 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.4, i64 0, i64 0))
br label %376
374: ; preds = %368, %364
%375 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %376
376: ; preds = %374, %372
br label %377
377: ; preds = %376, %358
br label %380
378: ; preds = %346
%379 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %380
380: ; preds = %378, %377
br label %463
381: ; preds = %307
%382 = load float, float* %12
%383 = load float, float* %11
%384 = fsub float %382, %383
%385 = load float, float* %9
%386 = load float, float* %10
%387 = fsub float %385, %386
%388 = fdiv float %384, %387
store float %388, float* %13
%389 = load float, float* %9
%390 = load float, float* %13
%391 = load float, float* %11
%392 = call float @llvm.fmuladd.f32(float %389, float %390, float %391)
store float %392, float* %14
%393 = load float, float* %20
%394 = load float, float* %19
%395 = fcmp olt float %393, %394
br i1 %395, label %396, label %399
396: ; preds = %381
%397 = load float, float* %19
store float %397, float* %34
%398 = load float, float* %20
store float %398, float* %35
br label %402
399: ; preds = %381
%400 = load float, float* %20
store float %400, float* %34
%401 = load float, float* %19
store float %401, float* %35
br label %402
402: ; preds = %399, %396
%403 = load float, float* %24
%404 = load float, float* %23
%405 = fcmp olt float %403, %404
br i1 %405, label %406, label %409
406: ; preds = %402
%407 = load float, float* %23
store float %407, float* %36
%408 = load float, float* %24
store float %408, float* %37
br label %412
409: ; preds = %402
%410 = load float, float* %24
store float %410, float* %36
%411 = load float, float* %23
store float %411, float* %37
br label %412
412: ; preds = %409, %406
%413 = load float, float* %1
%414 = load float, float* %2
%415 = fcmp ogt float %413, %414
br i1 %415, label %416, label %419
416: ; preds = %412
%417 = load float, float* %1
store float %417, float* %15
%418 = load float, float* %2
store float %418, float* %16
br label %422
419: ; preds = %412
%420 = load float, float* %2
store float %420, float* %15
%421 = load float, float* %1
store float %421, float* %16
br label %422
422: ; preds = %419, %416
%423 = load float, float* %13
%424 = load float, float* %18
%425 = fcmp ole float %423, %424
br i1 %425, label %426, label %460
426: ; preds = %422
%427 = load float, float* %13
%428 = load float, float* %17
%429 = fcmp oge float %427, %428
br i1 %429, label %430, label %460
430: ; preds = %426
%431 = load float, float* %13
%432 = load float, float* %22
%433 = fcmp ole float %431, %432
br i1 %433, label %434, label %460
434: ; preds = %430
%435 = load float, float* %13
%436 = load float, float* %21
%437 = fcmp oge float %435, %436
br i1 %437, label %438, label %460
438: ; preds = %434
%439 = load float, float* %14
%440 = load float, float* %34
%441 = fcmp ole float %439, %440
br i1 %441, label %442, label %460
442: ; preds = %438
%443 = load float, float* %14
%444 = load float, float* %35
%445 = fcmp oge float %443, %444
br i1 %445, label %446, label %460
446: ; preds = %442
%447 = load float, float* %14
%448 = load float, float* %36
%449 = fcmp ole float %447, %448
br i1 %449, label %450, label %460
450: ; preds = %446
%451 = load float, float* %14
%452 = load float, float* %37
%453 = fcmp oge float %451, %452
br i1 %453, label %454, label %460
454: ; preds = %450
%455 = load float, float* %13
%456 = fpext float %455 to double
%457 = load float, float* %14
%458 = fpext float %457 to double
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.6, i64 0, i64 0), double %456, double %458)
br label %462
460: ; preds = %450, %446, %442, %438, %434, %430, %426, %422
%461 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0))
br label %462
462: ; preds = %460, %454
br label %463
463: ; preds = %462, %380
br label %464
464: ; preds = %463, %306
br label %465
465: ; preds = %464, %231
ret void
}

LLVM IR (-O2):
@.str.1 = [32 x i8] c"Enter x1,y1,x2,y2,x3,y3,x4,y4: \00"
@stdin = global i32 0
@.str.2 = [16 x i8] c"The output is: \00"
@.str.3 = [43 x i8] c"The lines will intersect at (%.3f, %.3f).\0A\00"
@.str.6 = [42 x i8] c"The lines will intersect at (%.3f,%.3f).\0A\00"
@str = [180 x i8] c"Problem 2: Given 4 points ((x1,y1), (x2,y2), (x3,y3), (x4,y4)), \0Athe program will determine the intersection of the line segments formed by \0A(x1,y1), (x2,y2) and (x3,y3), (x4,y4).\00"
@str.14 = [17 x i8] c"No intersection.\00"
@str.15 = [26 x i8] c"The lines are coinciding.\00"
define void @Problem2() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca [1000 x i8]
%10 = alloca [1000 x i8]
%11 = alloca [8 x float]
%12 = bitcast float* %1 to i8*
%13 = bitcast float* %2 to i8*
%14 = bitcast float* %3 to i8*
%15 = bitcast float* %4 to i8*
%16 = bitcast float* %5 to i8*
%17 = bitcast float* %6 to i8*
%18 = bitcast float* %7 to i8*
%19 = bitcast float* %8 to i8*
%20 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 0
%21 = getelementptr inbounds [1000 x i8], [1000 x i8]* %10, i64 0, i64 0
%22 = bitcast [8 x float]* %11 to i8*
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([180 x i8], [180 x i8]* @str, i64 0, i64 0))
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0))
%25 = load i32, i32* @stdin
%26 = call i32 @fgets(i8* %20, i32 1000, i32 %25)
%27 = call i32 @strlen(i8* %20)
%28 = add nsw i32 %27, -1
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 %29
store i8 0, i8* %30
%31 = call i32 @strlen(i8* %20)
%32 = icmp sgt i32 %31, 0
br i1 %32, label %33, label %92
33: ; preds = %0, %55
%34 = phi i64 [ %59, %55 ], [ 0, %0 ]
%35 = phi i32 [ %61, %55 ], [ 0, %0 ]
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 %36
%38 = load i8, i8* %37
%39 = icmp eq i8 %38, 44
br i1 %39, label %55, label %40
40: ; preds = %33, %46
%41 = phi i64 [ %48, %46 ], [ %36, %33 ]
%42 = phi i8* [ %49, %46 ], [ %37, %33 ]
%43 = call i32 @strlen(i8* %20)
%44 = sext i32 %43 to i64
%45 = icmp slt i64 %41, %44
br i1 %45, label %46, label %52
46: ; preds = %40
%47 = call i32 @strncat(i8* %21, i8* %42, i32 1)
%48 = add nsw i64 %41, 1
%49 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 %48
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 44
br i1 %51, label %52, label %40
52: ; preds = %46, %40
%53 = phi i64 [ %41, %40 ], [ %48, %46 ]
%54 = trunc i64 %53 to i32
br label %55
55: ; preds = %52, %33
%56 = phi i32 [ %35, %33 ], [ %54, %52 ]
%57 = call float @atof(i8* %21)
%58 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 %34
store float %57, float* %58
%59 = add nuw i64 %34, 1
%60 = call i32 @memset(i8* %21, i32 0, i32 1000)
%61 = add nsw i32 %56, 1
%62 = call i32 @strlen(i8* %20)
%63 = icmp slt i32 %61, %62
br i1 %63, label %33, label %64
64: ; preds = %55
%65 = bitcast [8 x float]* %11 to <4 x float>*
%66 = load <4 x float>, <4 x float>* %65
%67 = shufflevector <4 x float> %66, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%68 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 1
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = shufflevector <4 x float> %70, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%72 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 2
%73 = bitcast float* %72 to <4 x float>*
%74 = load <4 x float>, <4 x float>* %73
%75 = shufflevector <4 x float> %74, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%76 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 3
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = shufflevector <4 x float> %78, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%80 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 4
%81 = load float, float* %80
%82 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 5
%83 = load float, float* %82
%84 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 6
%85 = load float, float* %84
%86 = getelementptr inbounds [8 x float], [8 x float]* %11, i64 0, i64 7
%87 = load float, float* %86
%88 = insertelement <2 x float> %79, float %87, i64 1
%89 = insertelement <2 x float> %71, float %83, i64 1
%90 = insertelement <2 x float> %75, float %85, i64 1
%91 = insertelement <2 x float> %67, float %81, i64 1
br label %92
92: ; preds = %64, %0
%93 = phi <2 x float> [ %88, %64 ], [ undef, %0 ]
%94 = phi <2 x float> [ %89, %64 ], [ undef, %0 ]
%95 = phi <2 x float> [ %90, %64 ], [ undef, %0 ]
%96 = phi <2 x float> [ %91, %64 ], [ undef, %0 ]
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0))
%98 = fsub <2 x float> %95, %96
%99 = extractelement <2 x float> %98, i64 0
%100 = fcmp oeq float %99, 0.000000e+00
%101 = extractelement <2 x float> %98, i64 1
%102 = fcmp oeq float %101, 0.000000e+00
br i1 %100, label %103, label %177
103: ; preds = %92
%104 = extractelement <2 x float> %93, i64 0
%105 = extractelement <2 x float> %94, i64 0
%106 = extractelement <2 x float> %95, i64 0
%107 = extractelement <2 x float> %96, i64 0
%108 = call i32 @vchecker1(float %107, float %105, float %106, float %104, float* %2, float* %4, float* %1, float* %3)
br i1 %102, label %109, label %139
109: ; preds = %103
%110 = extractelement <2 x float> %93, i64 1
%111 = extractelement <2 x float> %94, i64 1
%112 = extractelement <2 x float> %95, i64 1
%113 = extractelement <2 x float> %96, i64 1
%114 = call i32 @vchecker2(float %113, float %111, float %112, float %110, float* %6, float* %8, float* %5, float* %7)
%115 = call i32 @hvline(float* %2, float* %4, float* %1, float* %3, float* %6, float* %8, float* %5, float* %7)
%116 = load float, float* %2
%117 = load float, float* %6
%118 = fcmp oeq float %116, %117
br i1 %118, label %119, label %137
119: ; preds = %109
%120 = load float, float* %3
%121 = load float, float* %8
%122 = fcmp oeq float %120, %121
br i1 %122, label %123, label %128
123: ; preds = %119
%124 = load float, float* %1
%125 = fpext float %124 to double
%126 = fpext float %120 to double
%127 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %125, double %126)
br label %309
128: ; preds = %119
%129 = load float, float* %7
%130 = fcmp ult float %120, %129
%131 = fcmp ugt float %120, %121
%132 = select i1 %130, i1 true, i1 %131
br i1 %132, label %135, label %133
133: ; preds = %128
%134 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.15, i64 0, i64 0))
br label %309
135: ; preds = %128
%136 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
137: ; preds = %109
%138 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
139: ; preds = %103
%140 = extractelement <2 x float> %93, i64 1
%141 = extractelement <2 x float> %94, i64 1
%142 = extractelement <2 x float> %95, i64 1
%143 = extractelement <2 x float> %96, i64 1
%144 = call i32 @checker2(float %143, float %141, float %142, float %140, float* %6, float* %8, float* %5, float* %7)
%145 = load float, float* %8
%146 = load float, float* %7
%147 = fcmp olt float %145, %146
%148 = select i1 %147, float %146, float %145
%149 = select i1 %147, float %145, float %146
%150 = fsub float %140, %141
%151 = fdiv float %150, %101
%152 = fneg float %151
%153 = call float @llvm.fmuladd.f32(float %152, float %143, float %141)
%154 = load float, float* %2
%155 = call float @llvm.fmuladd.f32(float %151, float %154, float %153)
%156 = load float, float* %3
%157 = fcmp ult float %155, %156
%158 = load float, float* %4
%159 = fcmp ugt float %155, %158
%160 = select i1 %157, i1 true, i1 %159
%161 = load float, float* %5
%162 = fcmp ult float %154, %161
%163 = select i1 %160, i1 true, i1 %162
%164 = load float, float* %6
%165 = fcmp ugt float %154, %164
%166 = select i1 %163, i1 true, i1 %165
%167 = fcmp ugt float %155, %148
%168 = select i1 %166, i1 true, i1 %167
%169 = fcmp ult float %155, %149
%170 = select i1 %168, i1 true, i1 %169
br i1 %170, label %175, label %171
171: ; preds = %139
%172 = fpext float %154 to double
%173 = fpext float %155 to double
%174 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %172, double %173)
br label %309
175: ; preds = %139
%176 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
177: ; preds = %92
br i1 %102, label %178, label %222
178: ; preds = %177
%179 = extractelement <2 x float> %93, i64 0
%180 = extractelement <2 x float> %94, i64 0
%181 = extractelement <2 x float> %95, i64 0
%182 = extractelement <2 x float> %96, i64 0
%183 = call i32 @checker1(float %182, float %180, float %181, float %179, float* %2, float* %4, float* %1, float* %3)
%184 = extractelement <2 x float> %93, i64 1
%185 = extractelement <2 x float> %94, i64 1
%186 = extractelement <2 x float> %95, i64 1
%187 = extractelement <2 x float> %96, i64 1
%188 = call i32 @vchecker2(float %187, float %185, float %186, float %184, float* %6, float* %8, float* %5, float* %7)
%189 = load float, float* %4
%190 = load float, float* %3
%191 = fcmp olt float %189, %190
%192 = select i1 %191, float %190, float %189
%193 = select i1 %191, float %189, float %190
%194 = fsub <2 x float> %93, %94
%195 = extractelement <2 x float> %194, i64 0
%196 = fdiv float %195, %99
%197 = fneg float %196
%198 = call float @llvm.fmuladd.f32(float %197, float %182, float %180)
%199 = load float, float* %6
%200 = call float @llvm.fmuladd.f32(float %196, float %199, float %198)
%201 = load float, float* %7
%202 = fcmp ult float %200, %201
%203 = load float, float* %8
%204 = fcmp ugt float %200, %203
%205 = select i1 %202, i1 true, i1 %204
%206 = load float, float* %1
%207 = fcmp ult float %199, %206
%208 = select i1 %205, i1 true, i1 %207
%209 = load float, float* %2
%210 = fcmp ugt float %199, %209
%211 = select i1 %208, i1 true, i1 %210
%212 = fcmp ugt float %200, %192
%213 = select i1 %211, i1 true, i1 %212
%214 = fcmp ult float %200, %193
%215 = select i1 %213, i1 true, i1 %214
br i1 %215, label %220, label %216
216: ; preds = %178
%217 = fpext float %199 to double
%218 = fpext float %200 to double
%219 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %217, double %218)
br label %309
220: ; preds = %178
%221 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
222: ; preds = %177
%223 = fsub <2 x float> %93, %94
%224 = fdiv <2 x float> %223, %98
%225 = extractelement <2 x float> %224, i64 0
%226 = fneg float %225
%227 = extractelement <2 x float> %94, i64 0
%228 = extractelement <2 x float> %96, i64 0
%229 = call float @llvm.fmuladd.f32(float %226, float %228, float %227)
%230 = extractelement <2 x float> %224, i64 1
%231 = fneg float %230
%232 = extractelement <2 x float> %94, i64 1
%233 = extractelement <2 x float> %96, i64 1
%234 = call float @llvm.fmuladd.f32(float %231, float %233, float %232)
%235 = extractelement <2 x float> %93, i64 0
%236 = extractelement <2 x float> %95, i64 0
%237 = call i32 @checker1(float %228, float %227, float %236, float %235, float* %2, float* %4, float* %1, float* %3)
%238 = extractelement <2 x float> %93, i64 1
%239 = extractelement <2 x float> %95, i64 1
%240 = call i32 @checker2(float %233, float %232, float %239, float %238, float* %6, float* %8, float* %5, float* %7)
%241 = call i32 @hline(float* %2, float* %4, float* %1, float* %3, float* %6, float* %8, float* %5, float* %7)
%242 = fcmp oeq float %225, %230
br i1 %242, label %243, label %269
243: ; preds = %222
%244 = fcmp oeq float %229, %234
br i1 %244, label %245, label %267
245: ; preds = %243
%246 = load float, float* %1
%247 = load float, float* %2
%248 = fcmp oeq float %246, %247
br i1 %248, label %249, label %257
249: ; preds = %245
%250 = load float, float* %3
%251 = load float, float* %8
%252 = fcmp oeq float %250, %251
br i1 %252, label %253, label %257
253: ; preds = %249
%254 = fpext float %246 to double
%255 = fpext float %250 to double
%256 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), double %254, double %255)
br label %309
257: ; preds = %249, %245
%258 = load float, float* %5
%259 = fcmp ult float %246, %258
%260 = load float, float* %6
%261 = fcmp ugt float %246, %260
%262 = select i1 %259, i1 true, i1 %261
br i1 %262, label %265, label %263
263: ; preds = %257
%264 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.15, i64 0, i64 0))
br label %309
265: ; preds = %257
%266 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
267: ; preds = %243
%268 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
269: ; preds = %222
%270 = fsub float %234, %229
%271 = fsub float %225, %230
%272 = fdiv float %270, %271
%273 = call float @llvm.fmuladd.f32(float %225, float %272, float %229)
%274 = load float, float* %4
%275 = load float, float* %3
%276 = fcmp olt float %274, %275
%277 = select i1 %276, float %275, float %274
%278 = select i1 %276, float %274, float %275
%279 = load float, float* %8
%280 = load float, float* %7
%281 = fcmp olt float %279, %280
%282 = select i1 %281, float %280, float %279
%283 = select i1 %281, float %279, float %280
%284 = load float, float* %2
%285 = fcmp ugt float %272, %284
%286 = load float, float* %1
%287 = fcmp ult float %272, %286
%288 = select i1 %285, i1 true, i1 %287
%289 = load float, float* %6
%290 = fcmp ugt float %272, %289
%291 = select i1 %288, i1 true, i1 %290
%292 = load float, float* %5
%293 = fcmp ult float %272, %292
%294 = select i1 %291, i1 true, i1 %293
%295 = fcmp ugt float %273, %277
%296 = select i1 %294, i1 true, i1 %295
%297 = fcmp ult float %273, %278
%298 = select i1 %296, i1 true, i1 %297
%299 = fcmp ugt float %273, %282
%300 = select i1 %298, i1 true, i1 %299
%301 = fcmp ult float %273, %283
%302 = select i1 %300, i1 true, i1 %301
br i1 %302, label %307, label %303
303: ; preds = %269
%304 = fpext float %272 to double
%305 = fpext float %273 to double
%306 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.6, i64 0, i64 0), double %304, double %305)
br label %309
307: ; preds = %269
%308 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.14, i64 0, i64 0))
br label %309
309: ; preds = %303, %307, %216, %220, %171, %175, %267, %263, %265, %253, %123, %135, %133, %137
ret void
}