#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ print_float_in_bin(float);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdout;
scalar_t__ strcmp(char *, char *);
float strtof(char *, int /*<<< orphan*/ *);
int main(int argc, char **argv) {
  if (argc < 3) {
    fprintf(stderr, "Usage: fexpl cmd arg1 [arg2]\n");
    fprintf(stderr, "Params:\n\tcmd = {bin, add, sub, mul, div}\n");
    exit(-1);
  }
  assert(sizeof(float) == ((32) >> 3));
  if (strcmp(argv[1], "bin") == 0) {
    float value_to_explore = strtof(argv[2], NULL);
    fprintf(stdout, "Format: "
                    "\E[41m"
                    "Sign"
                    "\E[m"
                    ", "
                    "\E[44m"
                    "Exponent"
                    "\E[m"
                    ", "
                    "\E[45m"
                    "Mantissa"
                    "\E[m"
                    ".\n");
    fprintf(stdout,
            "Binary of %."
            "50"
            "f:\n",
            value_to_explore);
    print_float_in_bin(value_to_explore);
  } else if (strcmp(argv[1], "add") == 0) {
    do {
      if (argc < 4) {
        fprintf(stderr, "Command "
                        "+"
                        " expects to args\n");
        exit(-1);
      }
      float arg1 = strtof(argv[2], NULL);
      fprintf(stdout,
              "Arg1 is %."
              "50"
              "f\n",
              arg1);
      print_float_in_bin(arg1);
      float arg2 = strtof(argv[3], NULL);
      fprintf(stdout,
              "Arg2 is %."
              "50"
              "f\n",
              arg2);
      print_float_in_bin(arg2);
      fprintf(stdout,
              "+"
              " result is %."
              "50"
              "f\n",
              arg1 + arg2);
      print_float_in_bin(arg1 + arg2);
    } while (0);
  } else if (strcmp(argv[1], "mul") == 0) {
    do {
      if (argc < 4) {
        fprintf(stderr, "Command "
                        "*"
                        " expects to args\n");
        exit(-1);
      }
      float arg1 = strtof(argv[2], NULL);
      fprintf(stdout,
              "Arg1 is %."
              "50"
              "f\n",
              arg1);
      print_float_in_bin(arg1);
      float arg2 = strtof(argv[3], NULL);
      fprintf(stdout,
              "Arg2 is %."
              "50"
              "f\n",
              arg2);
      print_float_in_bin(arg2);
      fprintf(stdout,
              "*"
              " result is %."
              "50"
              "f\n",
              arg1 * arg2);
      print_float_in_bin(arg1 * arg2);
    } while (0);
  } else if (strcmp(argv[1], "sub") == 0) {
    do {
      if (argc < 4) {
        fprintf(stderr, "Command "
                        "-"
                        " expects to args\n");
        exit(-1);
      }
      float arg1 = strtof(argv[2], NULL);
      fprintf(stdout,
              "Arg1 is %."
              "50"
              "f\n",
              arg1);
      print_float_in_bin(arg1);
      float arg2 = strtof(argv[3], NULL);
      fprintf(stdout,
              "Arg2 is %."
              "50"
              "f\n",
              arg2);
      print_float_in_bin(arg2);
      fprintf(stdout,
              "-"
              " result is %."
              "50"
              "f\n",
              arg1 - arg2);
      print_float_in_bin(arg1 - arg2);
    } while (0);
  } else if (strcmp(argv[1], "div") == 0) {
    do {
      if (argc < 4) {
        fprintf(stderr, "Command "
                        "/"
                        " expects to args\n");
        exit(-1);
      }
      float arg1 = strtof(argv[2], NULL);
      fprintf(stdout,
              "Arg1 is %."
              "50"
              "f\n",
              arg1);
      print_float_in_bin(arg1);
      float arg2 = strtof(argv[3], NULL);
      fprintf(stdout,
              "Arg2 is %."
              "50"
              "f\n",
              arg2);
      print_float_in_bin(arg2);
      fprintf(stdout,
              "/"
              " result is %."
              "50"
              "f\n",
              arg1 / arg2);
      print_float_in_bin(arg1 / arg2);
    } while (0);
  } else {
    fprintf(stderr, "Unknown command: %s\n", argv[1]);
    exit(-1);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x3,-0x8(%rbp)
jge    11b8 <main+0x58>
mov    0x2e59(%rip),%rax
mov    (%rax),%edi
lea    0xe70(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    0x2e42(%rip),%rax
mov    (%rax),%edi
lea    0xe77(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    $0x1,%edi
call   1060 <assert@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe77(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
jne    123c <main+0xdc>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x14(%rbp)
mov    0x2ddb(%rip),%rax
mov    (%rax),%edi
lea    0xe46(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    0x2dc4(%rip),%rax
mov    (%rax),%edi
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe61(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x14(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
jmp    1695 <main+0x535>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe4e(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
jne    1343 <main+0x1e3>
jmp    125f <main+0xff>
cmpl   $0x4,-0x8(%rbp)
jge    128a <main+0x12a>
mov    0x2d70(%rip),%rax
mov    (%rax),%edi
lea    0xe24(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x18(%rbp)
mov    0x2d31(%rip),%rax
mov    (%rax),%edi
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdff(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x18(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x1c(%rbp)
mov    0x2cf1(%rip),%rax
mov    (%rax),%edi
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdce(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x1c(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x2cc7(%rip),%rax
mov    (%rax),%edi
movss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdae(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
jmp    1690 <main+0x530>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xd97(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
jne    144a <main+0x2ea>
jmp    1366 <main+0x206>
cmpl   $0x4,-0x8(%rbp)
jge    1391 <main+0x231>
mov    0x2c69(%rip),%rax
mov    (%rax),%edi
lea    0xd6d(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x20(%rbp)
mov    0x2c2a(%rip),%rax
mov    (%rax),%edi
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcf8(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x20(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x24(%rbp)
mov    0x2bea(%rip),%rax
mov    (%rax),%edi
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcc7(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x24(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x2bc0(%rip),%rax
mov    (%rax),%edi
movss  -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcd9(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
jmp    168b <main+0x52b>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xcc2(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
jne    1551 <main+0x3f1>
jmp    146d <main+0x30d>
cmpl   $0x4,-0x8(%rbp)
jge    1498 <main+0x338>
mov    0x2b62(%rip),%rax
mov    (%rax),%edi
lea    0xc98(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x28(%rbp)
mov    0x2b23(%rip),%rax
mov    (%rax),%edi
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbf1(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x28(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x2c(%rbp)
mov    0x2ae3(%rip),%rax
mov    (%rax),%edi
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbc0(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x2c(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x2ab9(%rip),%rax
mov    (%rax),%edi
movss  -0x28(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc04(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x28(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
jmp    1686 <main+0x526>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xbed(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
jne    1658 <main+0x4f8>
jmp    1574 <main+0x414>
cmpl   $0x4,-0x8(%rbp)
jge    159f <main+0x43f>
mov    0x2a5b(%rip),%rax
mov    (%rax),%edi
lea    0xbc3(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x30(%rbp)
mov    0x2a1c(%rip),%rax
mov    (%rax),%edi
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xaea(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x30(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtof@plt>
movss  %xmm0,-0x34(%rbp)
mov    0x29dc(%rip),%rax
mov    (%rax),%edi
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xab9(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x34(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x29b2(%rip),%rax
mov    (%rax),%edi
movss  -0x30(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb2f(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  -0x30(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
call   1040 <print_float_in_bin@plt>
jmp    1681 <main+0x521>
mov    0x2981(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdx
lea    0xb0f(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
jmp    1686 <main+0x526>
jmp    168b <main+0x52b>
jmp    1690 <main+0x530>
jmp    1695 <main+0x535>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
push   %rax
cmp    $0x2,%edi
jle    1497 <main+0x337>
mov    %rsi,%rbx
mov    %edi,%ebp
mov    $0x1,%edi
call   1060 <assert@plt>
mov    0x8(%rbx),%rdi
lea    0xec2(%rip),%rsi
call   1050 <strcmp@plt>
test   %rax,%rax
je     128b <main+0x12b>
mov    0x8(%rbx),%rdi
lea    0xefa(%rip),%rsi
call   1050 <strcmp@plt>
test   %rax,%rax
je     12c9 <main+0x169>
mov    0x8(%rbx),%rdi
lea    0xf31(%rip),%rsi
call   1050 <strcmp@plt>
test   %rax,%rax
je     135c <main+0x1fc>
mov    0x8(%rbx),%rdi
lea    0xf4a(%rip),%rsi
call   1050 <strcmp@plt>
test   %rax,%rax
je     13ef <main+0x28f>
mov    0x8(%rbx),%rdi
lea    0xf63(%rip),%rsi
call   1050 <strcmp@plt>
test   %rax,%rax
jne    14da <main+0x37a>
cmp    $0x3,%ebp
jbe    14ff <main+0x39f>
mov    0x10(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,(%rsp)
mov    0x2dc0(%rip),%rbp
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xe92(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  (%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x18(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,0x4(%rsp)
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xe71(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  0x4(%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x0(%rbp),%edi
movss  (%rsp),%xmm0
divss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xee6(%rip),%rsi
jmp    147d <main+0x31d>
mov    0x10(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,(%rsp)
mov    0x2d36(%rip),%rbx
mov    (%rbx),%edi
lea    0xda1(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    (%rbx),%edi
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdc3(%rip),%rsi
jmp    147d <main+0x31d>
cmp    $0x3,%ebp
jbe    14c8 <main+0x368>
mov    0x10(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,(%rsp)
mov    0x2cef(%rip),%rbp
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xdc1(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  (%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x18(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,0x4(%rsp)
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xda0(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  0x4(%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x0(%rbp),%edi
movss  (%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xd7f(%rip),%rsi
jmp    147d <main+0x31d>
cmp    $0x3,%ebp
jbe    1511 <main+0x3b1>
mov    0x10(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,(%rsp)
mov    0x2c5c(%rip),%rbp
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xd2e(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  (%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x18(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,0x4(%rsp)
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xd0d(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  0x4(%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x0(%rbp),%edi
movss  (%rsp),%xmm0
mulss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xd1e(%rip),%rsi
jmp    147d <main+0x31d>
cmp    $0x3,%ebp
jbe    1523 <main+0x3c3>
mov    0x10(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,(%rsp)
mov    0x2bc9(%rip),%rbp
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xc9b(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  (%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x18(%rbx),%rdi
xor    %esi,%esi
call   1030 <strtof@plt>
movss  %xmm0,0x4(%rsp)
mov    0x0(%rbp),%edi
cvtss2sd %xmm0,%xmm0
lea    0xc7a(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  0x4(%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
mov    0x0(%rbp),%edi
movss  (%rsp),%xmm0
subss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xcbd(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movss  (%rsp),%xmm0
call   1040 <print_float_in_bin@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret
mov    0x2b42(%rip),%rbx
mov    (%rbx),%edi
lea    0xb59(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    (%rbx),%edi
lea    0xb67(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    0x2b11(%rip),%rax
mov    (%rax),%edi
lea    0xbc5(%rip),%rsi
jmp    14b7 <main+0x357>
mov    0x2aff(%rip),%rax
mov    (%rax),%edi
mov    0x8(%rbx),%rdx
lea    0xc91(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    0x2ada(%rip),%rax
mov    (%rax),%edi
lea    0xc42(%rip),%rsi
jmp    14b7 <main+0x357>
mov    0x2ac8(%rip),%rax
mov    (%rax),%edi
lea    0xbcc(%rip),%rsi
jmp    14b7 <main+0x357>
mov    0x2ab6(%rip),%rax
mov    (%rax),%edi
lea    0xbec(%rip),%rsi
jmp    14b7 <main+0x357>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [30 x i8] c"Usage: fexpl cmd arg1 [arg2]\0A\00"
@.str.1 = [42 x i8] c"Params:\0A\09cmd = {bin, add, sub, mul, div}\0A\00"
@.str.2 = [4 x i8] c"bin\00"
@stdout = global i32 0
@.str.3 = [59 x i8] c"Format: \1B[41mSign\1B[m, \1B[44mExponent\1B[m, \1B[45mMantissa\1B[m.\0A\00"
@.str.4 = [18 x i8] c"Binary of %.50f:\0A\00"
@.str.5 = [4 x i8] c"add\00"
@.str.6 = [27 x i8] c"Command + expects to args\0A\00"
@.str.7 = [15 x i8] c"Arg1 is %.50f\0A\00"
@.str.8 = [15 x i8] c"Arg2 is %.50f\0A\00"
@.str.9 = [19 x i8] c"+ result is %.50f\0A\00"
@.str.10 = [4 x i8] c"mul\00"
@.str.11 = [27 x i8] c"Command * expects to args\0A\00"
@.str.12 = [19 x i8] c"* result is %.50f\0A\00"
@.str.13 = [4 x i8] c"sub\00"
@.str.14 = [27 x i8] c"Command - expects to args\0A\00"
@.str.15 = [19 x i8] c"- result is %.50f\0A\00"
@.str.16 = [4 x i8] c"div\00"
@.str.17 = [27 x i8] c"Command / expects to args\0A\00"
@.str.18 = [19 x i8] c"/ result is %.50f\0A\00"
@.str.19 = [21 x i8] c"Unknown command: %s\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%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
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%15 = load i32, i32* %4
%16 = icmp slt i32 %15, 3
br i1 %16, label %17, label %23
17: ; preds = %2
%18 = load i32, i32* @stderr
%19 = call i32 (i32, i8*, ...) @fprintf(i32 %18, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0))
%20 = load i32, i32* @stderr
%21 = call i32 (i32, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0))
%22 = call i32 @exit(i32 -1)
unreachable
23: ; preds = %2
%24 = call i32 @assert(i32 1)
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
%28 = call i64 @strcmp(i8* %27, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
%29 = icmp eq i64 %28, 0
br i1 %29, label %30, label %43
30: ; preds = %23
%31 = load i8**, i8*** %5
%32 = getelementptr inbounds i8*, i8** %31, i64 2
%33 = load i8*, i8** %32
%34 = call float @strtof(i8* %33, i32* null)
store float %34, float* %6
%35 = load i32, i32* @stdout
%36 = call i32 (i32, i8*, ...) @fprintf(i32 %35, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.3, i64 0, i64 0))
%37 = load i32, i32* @stdout
%38 = load float, float* %6
%39 = fpext float %38 to double
%40 = call i32 (i32, i8*, ...) @fprintf(i32 %37, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), double %39)
%41 = load float, float* %6
%42 = call i32 @print_float_in_bin(float %41)
br label %238
43: ; preds = %23
%44 = load i8**, i8*** %5
%45 = getelementptr inbounds i8*, i8** %44, i64 1
%46 = load i8*, i8** %45
%47 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
%48 = icmp eq i64 %47, 0
br i1 %48, label %49, label %89
49: ; preds = %43
br label %50
50: ; preds = %49
%51 = load i32, i32* %4
%52 = icmp slt i32 %51, 4
br i1 %52, label %53, label %57
53: ; preds = %50
%54 = load i32, i32* @stderr
%55 = call i32 (i32, i8*, ...) @fprintf(i32 %54, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.6, i64 0, i64 0))
%56 = call i32 @exit(i32 -1)
unreachable
57: ; preds = %50
%58 = load i8**, i8*** %5
%59 = getelementptr inbounds i8*, i8** %58, i64 2
%60 = load i8*, i8** %59
%61 = call float @strtof(i8* %60, i32* null)
store float %61, float* %7
%62 = load i32, i32* @stdout
%63 = load float, float* %7
%64 = fpext float %63 to double
%65 = call i32 (i32, i8*, ...) @fprintf(i32 %62, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %64)
%66 = load float, float* %7
%67 = call i32 @print_float_in_bin(float %66)
%68 = load i8**, i8*** %5
%69 = getelementptr inbounds i8*, i8** %68, i64 3
%70 = load i8*, i8** %69
%71 = call float @strtof(i8* %70, i32* null)
store float %71, float* %8
%72 = load i32, i32* @stdout
%73 = load float, float* %8
%74 = fpext float %73 to double
%75 = call i32 (i32, i8*, ...) @fprintf(i32 %72, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %74)
%76 = load float, float* %8
%77 = call i32 @print_float_in_bin(float %76)
%78 = load i32, i32* @stdout
%79 = load float, float* %7
%80 = load float, float* %8
%81 = fadd float %79, %80
%82 = fpext float %81 to double
%83 = call i32 (i32, i8*, ...) @fprintf(i32 %78, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), double %82)
%84 = load float, float* %7
%85 = load float, float* %8
%86 = fadd float %84, %85
%87 = call i32 @print_float_in_bin(float %86)
br label %88
88: ; preds = %57
br label %237
89: ; preds = %43
%90 = load i8**, i8*** %5
%91 = getelementptr inbounds i8*, i8** %90, i64 1
%92 = load i8*, i8** %91
%93 = call i64 @strcmp(i8* %92, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0))
%94 = icmp eq i64 %93, 0
br i1 %94, label %95, label %135
95: ; preds = %89
br label %96
96: ; preds = %95
%97 = load i32, i32* %4
%98 = icmp slt i32 %97, 4
br i1 %98, label %99, label %103
99: ; preds = %96
%100 = load i32, i32* @stderr
%101 = call i32 (i32, i8*, ...) @fprintf(i32 %100, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0))
%102 = call i32 @exit(i32 -1)
unreachable
103: ; preds = %96
%104 = load i8**, i8*** %5
%105 = getelementptr inbounds i8*, i8** %104, i64 2
%106 = load i8*, i8** %105
%107 = call float @strtof(i8* %106, i32* null)
store float %107, float* %9
%108 = load i32, i32* @stdout
%109 = load float, float* %9
%110 = fpext float %109 to double
%111 = call i32 (i32, i8*, ...) @fprintf(i32 %108, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %110)
%112 = load float, float* %9
%113 = call i32 @print_float_in_bin(float %112)
%114 = load i8**, i8*** %5
%115 = getelementptr inbounds i8*, i8** %114, i64 3
%116 = load i8*, i8** %115
%117 = call float @strtof(i8* %116, i32* null)
store float %117, float* %10
%118 = load i32, i32* @stdout
%119 = load float, float* %10
%120 = fpext float %119 to double
%121 = call i32 (i32, i8*, ...) @fprintf(i32 %118, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %120)
%122 = load float, float* %10
%123 = call i32 @print_float_in_bin(float %122)
%124 = load i32, i32* @stdout
%125 = load float, float* %9
%126 = load float, float* %10
%127 = fmul float %125, %126
%128 = fpext float %127 to double
%129 = call i32 (i32, i8*, ...) @fprintf(i32 %124, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, i64 0, i64 0), double %128)
%130 = load float, float* %9
%131 = load float, float* %10
%132 = fmul float %130, %131
%133 = call i32 @print_float_in_bin(float %132)
br label %134
134: ; preds = %103
br label %236
135: ; preds = %89
%136 = load i8**, i8*** %5
%137 = getelementptr inbounds i8*, i8** %136, i64 1
%138 = load i8*, i8** %137
%139 = call i64 @strcmp(i8* %138, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0))
%140 = icmp eq i64 %139, 0
br i1 %140, label %141, label %181
141: ; preds = %135
br label %142
142: ; preds = %141
%143 = load i32, i32* %4
%144 = icmp slt i32 %143, 4
br i1 %144, label %145, label %149
145: ; preds = %142
%146 = load i32, i32* @stderr
%147 = call i32 (i32, i8*, ...) @fprintf(i32 %146, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.14, i64 0, i64 0))
%148 = call i32 @exit(i32 -1)
unreachable
149: ; preds = %142
%150 = load i8**, i8*** %5
%151 = getelementptr inbounds i8*, i8** %150, i64 2
%152 = load i8*, i8** %151
%153 = call float @strtof(i8* %152, i32* null)
store float %153, float* %11
%154 = load i32, i32* @stdout
%155 = load float, float* %11
%156 = fpext float %155 to double
%157 = call i32 (i32, i8*, ...) @fprintf(i32 %154, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %156)
%158 = load float, float* %11
%159 = call i32 @print_float_in_bin(float %158)
%160 = load i8**, i8*** %5
%161 = getelementptr inbounds i8*, i8** %160, i64 3
%162 = load i8*, i8** %161
%163 = call float @strtof(i8* %162, i32* null)
store float %163, float* %12
%164 = load i32, i32* @stdout
%165 = load float, float* %12
%166 = fpext float %165 to double
%167 = call i32 (i32, i8*, ...) @fprintf(i32 %164, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %166)
%168 = load float, float* %12
%169 = call i32 @print_float_in_bin(float %168)
%170 = load i32, i32* @stdout
%171 = load float, float* %11
%172 = load float, float* %12
%173 = fsub float %171, %172
%174 = fpext float %173 to double
%175 = call i32 (i32, i8*, ...) @fprintf(i32 %170, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.15, i64 0, i64 0), double %174)
%176 = load float, float* %11
%177 = load float, float* %12
%178 = fsub float %176, %177
%179 = call i32 @print_float_in_bin(float %178)
br label %180
180: ; preds = %149
br label %235
181: ; preds = %135
%182 = load i8**, i8*** %5
%183 = getelementptr inbounds i8*, i8** %182, i64 1
%184 = load i8*, i8** %183
%185 = call i64 @strcmp(i8* %184, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0))
%186 = icmp eq i64 %185, 0
br i1 %186, label %187, label %227
187: ; preds = %181
br label %188
188: ; preds = %187
%189 = load i32, i32* %4
%190 = icmp slt i32 %189, 4
br i1 %190, label %191, label %195
191: ; preds = %188
%192 = load i32, i32* @stderr
%193 = call i32 (i32, i8*, ...) @fprintf(i32 %192, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.17, i64 0, i64 0))
%194 = call i32 @exit(i32 -1)
unreachable
195: ; preds = %188
%196 = load i8**, i8*** %5
%197 = getelementptr inbounds i8*, i8** %196, i64 2
%198 = load i8*, i8** %197
%199 = call float @strtof(i8* %198, i32* null)
store float %199, float* %13
%200 = load i32, i32* @stdout
%201 = load float, float* %13
%202 = fpext float %201 to double
%203 = call i32 (i32, i8*, ...) @fprintf(i32 %200, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %202)
%204 = load float, float* %13
%205 = call i32 @print_float_in_bin(float %204)
%206 = load i8**, i8*** %5
%207 = getelementptr inbounds i8*, i8** %206, i64 3
%208 = load i8*, i8** %207
%209 = call float @strtof(i8* %208, i32* null)
store float %209, float* %14
%210 = load i32, i32* @stdout
%211 = load float, float* %14
%212 = fpext float %211 to double
%213 = call i32 (i32, i8*, ...) @fprintf(i32 %210, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %212)
%214 = load float, float* %14
%215 = call i32 @print_float_in_bin(float %214)
%216 = load i32, i32* @stdout
%217 = load float, float* %13
%218 = load float, float* %14
%219 = fdiv float %217, %218
%220 = fpext float %219 to double
%221 = call i32 (i32, i8*, ...) @fprintf(i32 %216, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.18, i64 0, i64 0), double %220)
%222 = load float, float* %13
%223 = load float, float* %14
%224 = fdiv float %222, %223
%225 = call i32 @print_float_in_bin(float %224)
br label %226
226: ; preds = %195
br label %234
227: ; preds = %181
%228 = load i32, i32* @stderr
%229 = load i8**, i8*** %5
%230 = getelementptr inbounds i8*, i8** %229, i64 1
%231 = load i8*, i8** %230
%232 = call i32 (i32, i8*, ...) @fprintf(i32 %228, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.19, i64 0, i64 0), i8* %231)
%233 = call i32 @exit(i32 -1)
unreachable
234: ; preds = %226
br label %235
235: ; preds = %234, %180
br label %236
236: ; preds = %235, %134
br label %237
237: ; preds = %236, %88
br label %238
238: ; preds = %237, %30
%239 = load i32, i32* %3
ret i32 %239
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [30 x i8] c"Usage: fexpl cmd arg1 [arg2]\0A\00"
@.str.1 = [42 x i8] c"Params:\0A\09cmd = {bin, add, sub, mul, div}\0A\00"
@.str.2 = [4 x i8] c"bin\00"
@stdout = global i32 0
@.str.3 = [59 x i8] c"Format: \1B[41mSign\1B[m, \1B[44mExponent\1B[m, \1B[45mMantissa\1B[m.\0A\00"
@.str.4 = [18 x i8] c"Binary of %.50f:\0A\00"
@.str.5 = [4 x i8] c"add\00"
@.str.6 = [27 x i8] c"Command + expects to args\0A\00"
@.str.7 = [15 x i8] c"Arg1 is %.50f\0A\00"
@.str.8 = [15 x i8] c"Arg2 is %.50f\0A\00"
@.str.9 = [19 x i8] c"+ result is %.50f\0A\00"
@.str.10 = [4 x i8] c"mul\00"
@.str.11 = [27 x i8] c"Command * expects to args\0A\00"
@.str.12 = [19 x i8] c"* result is %.50f\0A\00"
@.str.13 = [4 x i8] c"sub\00"
@.str.14 = [27 x i8] c"Command - expects to args\0A\00"
@.str.15 = [19 x i8] c"- result is %.50f\0A\00"
@.str.16 = [4 x i8] c"div\00"
@.str.17 = [27 x i8] c"Command / expects to args\0A\00"
@.str.18 = [19 x i8] c"/ result is %.50f\0A\00"
@.str.19 = [21 x i8] c"Unknown command: %s\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp slt i32 %0, 3
br i1 %3, label %4, label %10
4: ; preds = %2
%5 = load i32, i32* @stderr
%6 = tail call i32 (i32, i8*, ...) @fprintf(i32 %5, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = tail call i32 (i32, i8*, ...) @fprintf(i32 %7, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0))
%9 = tail call i32 @exit(i32 -1)
unreachable
10: ; preds = %2
%11 = tail call i32 @assert(i32 1)
%12 = getelementptr inbounds i8*, i8** %1, i64 1
%13 = load i8*, i8** %12
%14 = tail call i64 @strcmp(i8* %13, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
%15 = icmp eq i64 %14, 0
br i1 %15, label %16, label %25
16: ; preds = %10
%17 = getelementptr inbounds i8*, i8** %1, i64 2
%18 = load i8*, i8** %17
%19 = tail call float @strtof(i8* nocapture %18, i32* null)
%20 = load i32, i32* @stdout
%21 = tail call i32 (i32, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.3, i64 0, i64 0))
%22 = load i32, i32* @stdout
%23 = fpext float %19 to double
%24 = tail call i32 (i32, i8*, ...) @fprintf(i32 %22, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), double %23)
br label %146
25: ; preds = %10
%26 = load i8*, i8** %12
%27 = tail call i64 @strcmp(i8* %26, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
%28 = icmp eq i64 %27, 0
br i1 %28, label %29, label %54
29: ; preds = %25
%30 = icmp ult i32 %0, 4
br i1 %30, label %31, label %35
31: ; preds = %29
%32 = load i32, i32* @stderr
%33 = tail call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.6, i64 0, i64 0))
%34 = tail call i32 @exit(i32 -1)
unreachable
35: ; preds = %29
%36 = getelementptr inbounds i8*, i8** %1, i64 2
%37 = load i8*, i8** %36
%38 = tail call float @strtof(i8* nocapture %37, i32* null)
%39 = load i32, i32* @stdout
%40 = fpext float %38 to double
%41 = tail call i32 (i32, i8*, ...) @fprintf(i32 %39, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %40)
%42 = tail call i32 @print_float_in_bin(float %38)
%43 = getelementptr inbounds i8*, i8** %1, i64 3
%44 = load i8*, i8** %43
%45 = tail call float @strtof(i8* nocapture %44, i32* null)
%46 = load i32, i32* @stdout
%47 = fpext float %45 to double
%48 = tail call i32 (i32, i8*, ...) @fprintf(i32 %46, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %47)
%49 = tail call i32 @print_float_in_bin(float %45)
%50 = load i32, i32* @stdout
%51 = fadd float %38, %45
%52 = fpext float %51 to double
%53 = tail call i32 (i32, i8*, ...) @fprintf(i32 %50, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), double %52)
br label %146
54: ; preds = %25
%55 = load i8*, i8** %12
%56 = tail call i64 @strcmp(i8* %55, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0))
%57 = icmp eq i64 %56, 0
br i1 %57, label %58, label %83
58: ; preds = %54
%59 = icmp ult i32 %0, 4
br i1 %59, label %60, label %64
60: ; preds = %58
%61 = load i32, i32* @stderr
%62 = tail call i32 (i32, i8*, ...) @fprintf(i32 %61, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0))
%63 = tail call i32 @exit(i32 -1)
unreachable
64: ; preds = %58
%65 = getelementptr inbounds i8*, i8** %1, i64 2
%66 = load i8*, i8** %65
%67 = tail call float @strtof(i8* nocapture %66, i32* null)
%68 = load i32, i32* @stdout
%69 = fpext float %67 to double
%70 = tail call i32 (i32, i8*, ...) @fprintf(i32 %68, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %69)
%71 = tail call i32 @print_float_in_bin(float %67)
%72 = getelementptr inbounds i8*, i8** %1, i64 3
%73 = load i8*, i8** %72
%74 = tail call float @strtof(i8* nocapture %73, i32* null)
%75 = load i32, i32* @stdout
%76 = fpext float %74 to double
%77 = tail call i32 (i32, i8*, ...) @fprintf(i32 %75, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %76)
%78 = tail call i32 @print_float_in_bin(float %74)
%79 = load i32, i32* @stdout
%80 = fmul float %67, %74
%81 = fpext float %80 to double
%82 = tail call i32 (i32, i8*, ...) @fprintf(i32 %79, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, i64 0, i64 0), double %81)
br label %146
83: ; preds = %54
%84 = load i8*, i8** %12
%85 = tail call i64 @strcmp(i8* %84, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0))
%86 = icmp eq i64 %85, 0
br i1 %86, label %87, label %112
87: ; preds = %83
%88 = icmp ult i32 %0, 4
br i1 %88, label %89, label %93
89: ; preds = %87
%90 = load i32, i32* @stderr
%91 = tail call i32 (i32, i8*, ...) @fprintf(i32 %90, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.14, i64 0, i64 0))
%92 = tail call i32 @exit(i32 -1)
unreachable
93: ; preds = %87
%94 = getelementptr inbounds i8*, i8** %1, i64 2
%95 = load i8*, i8** %94
%96 = tail call float @strtof(i8* nocapture %95, i32* null)
%97 = load i32, i32* @stdout
%98 = fpext float %96 to double
%99 = tail call i32 (i32, i8*, ...) @fprintf(i32 %97, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %98)
%100 = tail call i32 @print_float_in_bin(float %96)
%101 = getelementptr inbounds i8*, i8** %1, i64 3
%102 = load i8*, i8** %101
%103 = tail call float @strtof(i8* nocapture %102, i32* null)
%104 = load i32, i32* @stdout
%105 = fpext float %103 to double
%106 = tail call i32 (i32, i8*, ...) @fprintf(i32 %104, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %105)
%107 = tail call i32 @print_float_in_bin(float %103)
%108 = load i32, i32* @stdout
%109 = fsub float %96, %103
%110 = fpext float %109 to double
%111 = tail call i32 (i32, i8*, ...) @fprintf(i32 %108, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.15, i64 0, i64 0), double %110)
br label %146
112: ; preds = %83
%113 = load i8*, i8** %12
%114 = tail call i64 @strcmp(i8* %113, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0))
%115 = icmp eq i64 %114, 0
br i1 %115, label %116, label %141
116: ; preds = %112
%117 = icmp ult i32 %0, 4
br i1 %117, label %118, label %122
118: ; preds = %116
%119 = load i32, i32* @stderr
%120 = tail call i32 (i32, i8*, ...) @fprintf(i32 %119, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.17, i64 0, i64 0))
%121 = tail call i32 @exit(i32 -1)
unreachable
122: ; preds = %116
%123 = getelementptr inbounds i8*, i8** %1, i64 2
%124 = load i8*, i8** %123
%125 = tail call float @strtof(i8* nocapture %124, i32* null)
%126 = load i32, i32* @stdout
%127 = fpext float %125 to double
%128 = tail call i32 (i32, i8*, ...) @fprintf(i32 %126, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %127)
%129 = tail call i32 @print_float_in_bin(float %125)
%130 = getelementptr inbounds i8*, i8** %1, i64 3
%131 = load i8*, i8** %130
%132 = tail call float @strtof(i8* nocapture %131, i32* null)
%133 = load i32, i32* @stdout
%134 = fpext float %132 to double
%135 = tail call i32 (i32, i8*, ...) @fprintf(i32 %133, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %134)
%136 = tail call i32 @print_float_in_bin(float %132)
%137 = load i32, i32* @stdout
%138 = fdiv float %125, %132
%139 = fpext float %138 to double
%140 = tail call i32 (i32, i8*, ...) @fprintf(i32 %137, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.18, i64 0, i64 0), double %139)
br label %146
141: ; preds = %112
%142 = load i32, i32* @stderr
%143 = load i8*, i8** %12
%144 = tail call i32 (i32, i8*, ...) @fprintf(i32 %142, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.19, i64 0, i64 0), i8* %143)
%145 = tail call i32 @exit(i32 -1)
unreachable
146: ; preds = %35, %93, %122, %64, %16
%147 = phi float [ %51, %35 ], [ %109, %93 ], [ %138, %122 ], [ %80, %64 ], [ %19, %16 ]
%148 = tail call i32 @print_float_in_bin(float %147)
ret i32 0
}