#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*/ Assertion_Assert(int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_add(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_cardinal(int);
int /*<<< orphan*/ Fractions_dec(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_div(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_half();
int /*<<< orphan*/ Fractions_inc(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_initFract(int, int, int);
int /*<<< orphan*/ Fractions_integer(int);
int /*<<< orphan*/ Fractions_isEqual(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_mult(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_negate(int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_one();
int /*<<< orphan*/ Fractions_pi();
int /*<<< orphan*/ Fractions_power(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_reciprocal(int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_root2();
int /*<<< orphan*/ Fractions_root6();
int /*<<< orphan*/ Fractions_simplify(int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_sin(int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_sub(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_tan(int /*<<< orphan*/);
int /*<<< orphan*/ Fractions_two();
int /*<<< orphan*/ Fractions_writeFract(int /*<<< orphan*/);
int /*<<< orphan*/ pf(int /*<<< orphan*/);
int /*<<< orphan*/ writeLn();
void regressionTest(void) {
  Assertion_Assert(Fractions_isEqual(
      Fractions_sub(Fractions_half(), Fractions_initFract(1, 1, 2)),
      Fractions_negate(Fractions_one())));
  Assertion_Assert(Fractions_isEqual(
      Fractions_sub(Fractions_initFract(1, 1, 2), Fractions_half()),
      Fractions_one()));
  Assertion_Assert(
      Fractions_isEqual(Fractions_sub(Fractions_initFract(1, 1, 2),
                                      Fractions_negate(Fractions_half())),
                        Fractions_two()));
  Assertion_Assert(
      Fractions_isEqual(Fractions_sub(Fractions_negate(Fractions_two()),
                                      Fractions_negate(Fractions_half())),
                        Fractions_negate(Fractions_initFract(1, 1, 2))));
  Assertion_Assert(
      Fractions_isEqual(Fractions_add(Fractions_negate(Fractions_one()),
                                      Fractions_negate(Fractions_half())),
                        Fractions_negate(Fractions_initFract(1, 1, 2))));
  Assertion_Assert(
      Fractions_isEqual(Fractions_add(Fractions_negate(Fractions_half()),
                                      Fractions_negate(Fractions_half())),
                        Fractions_integer(-1)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_add(Fractions_initFract(0, 1, 4), Fractions_initFract(0, 1, 5)),
      Fractions_initFract(0, 9, 20)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_add(Fractions_initFract(0, 9, 4), Fractions_initFract(0, 1, 5)),
      Fractions_initFract(2, 9, 20)));
  Assertion_Assert(
      Fractions_isEqual(Fractions_reciprocal(Fractions_initFract(0, 1, 9)),
                        Fractions_cardinal(9)));
  Assertion_Assert(
      Fractions_isEqual(Fractions_reciprocal(Fractions_initFract(0, 3, 10)),
                        Fractions_initFract(0, 10, 3)));
  Assertion_Assert(Fractions_isEqual(Fractions_reciprocal(Fractions_one()),
                                     Fractions_one()));
  Assertion_Assert(Fractions_isEqual(
      Fractions_mult(Fractions_reciprocal(Fractions_cardinal(2)),
                     Fractions_reciprocal(Fractions_cardinal(3))),
      Fractions_initFract(0, 1, 6)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_inc(Fractions_reciprocal(Fractions_cardinal(50)),
                    Fractions_reciprocal(Fractions_cardinal(100))),
      Fractions_initFract(0, 3, 100)));
  Assertion_Assert(
      Fractions_isEqual(Fractions_mult(Fractions_initFract(0, 22, 7),
                                       Fractions_initFract(0, 22, 7)),
                        Fractions_initFract(9, 43, 49)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_dec(Fractions_initFract(0, 1, 4), Fractions_initFract(0, 1, 2)),
      Fractions_negate(Fractions_initFract(0, 1, 4))));
  Assertion_Assert(Fractions_isEqual(
      Fractions_dec(Fractions_initFract(0, 1, 2), Fractions_initFract(0, 1, 4)),
      Fractions_initFract(0, 1, 4)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_dec(Fractions_initFract(3, 0, 0), Fractions_initFract(3, 1, 4)),
      Fractions_negate(Fractions_initFract(0, 1, 4))));
  Assertion_Assert(
      Fractions_isEqual(Fractions_mult(Fractions_integer(-1), Fractions_one()),
                        Fractions_integer(-1)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_integer(-1),
      Fractions_mult(Fractions_integer(-1), Fractions_one())));
  Assertion_Assert(
      Fractions_isEqual(Fractions_mult(Fractions_integer(-2), Fractions_one()),
                        Fractions_integer(-2)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_integer(-2),
      Fractions_mult(Fractions_integer(-2), Fractions_one())));
  Assertion_Assert(Fractions_isEqual(
      Fractions_integer(2),
      Fractions_mult(Fractions_integer(-2), Fractions_integer(-1))));
  Assertion_Assert(Fractions_isEqual(
      Fractions_mult(Fractions_integer(-2), Fractions_integer(-1)),
      Fractions_integer(2)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_mult(Fractions_integer(-2), Fractions_integer(1)),
      Fractions_integer(-2)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_mult(Fractions_integer(2), Fractions_integer(-1)),
      Fractions_integer(-2)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_add(Fractions_integer(-1), Fractions_integer(-1)),
      Fractions_integer(-2)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_integer(-2),
      Fractions_add(Fractions_integer(-1), Fractions_integer(-1))));
  Assertion_Assert(Fractions_isEqual(
      Fractions_add(Fractions_integer(-1), Fractions_integer(1)),
      Fractions_integer(0)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_add(Fractions_integer(1), Fractions_integer(-1)),
      Fractions_integer(0)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_sub(Fractions_integer(-1), Fractions_integer(-1)),
      Fractions_integer(0)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_integer(0),
      Fractions_sub(Fractions_integer(-1), Fractions_integer(-1))));
  Assertion_Assert(Fractions_isEqual(
      Fractions_sub(Fractions_integer(-1), Fractions_integer(1)),
      Fractions_integer(-2)));
  Assertion_Assert(Fractions_isEqual(
      Fractions_sub(Fractions_integer(1), Fractions_integer(-1)),
      Fractions_integer(2)));
  Fractions_writeFract(Fractions_pi());
  writeLn();
  pf(Fractions_simplify(Fractions_sin(Fractions_pi())));
  writeLn();
  pf(Fractions_simplify(
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(6)))));
  writeLn();
  pf(Fractions_simplify(
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(4)))));
  writeLn();
  pf(Fractions_simplify(Fractions_mult(
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(4))),
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(4))))));
  writeLn();
  pf(Fractions_simplify(Fractions_tan(
      Fractions_mult(Fractions_cardinal(5),
                     Fractions_div(Fractions_pi(), Fractions_cardinal(12))))));
  writeLn();
  pf(Fractions_simplify(
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(12)))));
  writeLn();
  pf(Fractions_simplify(Fractions_power(
      Fractions_sub(Fractions_root6(), Fractions_root2()), Fractions_two())));
  writeLn();
  pf(Fractions_simplify(Fractions_mult(
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(12))),
      Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(12))))));
  writeLn();
  pf(Fractions_simplify(Fractions_div(
      Fractions_mult(
          Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(12))),
          Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(12)))),
      Fractions_mult(
          Fractions_sin(Fractions_div(Fractions_pi(), Fractions_cardinal(12))),
          Fractions_sin(
              Fractions_div(Fractions_pi(), Fractions_cardinal(12)))))));
  writeLn();
}


x86 assembly (clang, -O0):
<regressionTest>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    %eax,-0x14c(%rbp)
mov    $0x1,%esi
mov    $0x2,%edx
mov    %esi,%edi
call   10e0 <Fractions_initFract@plt>
mov    -0x14c(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x148(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x148(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%esi
mov    $0x2,%edx
mov    %esi,%edi
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0x144(%rbp)
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    -0x144(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x140(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    -0x140(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%esi
mov    $0x2,%edx
mov    %esi,%edi
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0x13c(%rbp)
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x13c(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x138(%rbp)
mov    $0x0,%al
call   1120 <Fractions_two@plt>
mov    -0x138(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x0,%al
call   1120 <Fractions_two@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %eax,-0x134(%rbp)
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x134(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x130(%rbp)
mov    $0x1,%esi
mov    $0x2,%edx
mov    %esi,%edi
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x130(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %eax,-0x12c(%rbp)
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x12c(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x128(%rbp)
mov    $0x1,%esi
mov    $0x2,%edx
mov    %esi,%edi
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x128(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %eax,-0x124(%rbp)
mov    $0x0,%al
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0x124(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x120(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x120(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0x11c(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0x11c(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x118(%rbp)
xor    %edi,%edi
mov    $0x9,%esi
mov    $0x14,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0x118(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x9,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0x114(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0x114(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x110(%rbp)
mov    $0x2,%edi
mov    $0x9,%esi
mov    $0x14,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0x110(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x9,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,-0x10c(%rbp)
mov    $0x9,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x10c(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x3,%esi
mov    $0xa,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,-0x108(%rbp)
xor    %edi,%edi
mov    $0xa,%esi
mov    $0x3,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0x108(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,-0x104(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    -0x104(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x2,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,-0x100(%rbp)
mov    $0x3,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    -0x100(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0xfc(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x6,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xfc(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x32,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,-0xf8(%rbp)
mov    $0x64,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    -0xf8(%rbp),%edi
mov    %eax,%esi
call   1030 <Fractions_inc@plt>
mov    %eax,-0xf4(%rbp)
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x64,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xf4(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x16,%esi
mov    $0x7,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0xf0(%rbp)
xor    %edi,%edi
mov    $0x16,%esi
mov    $0x7,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xf0(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0xec(%rbp)
mov    $0x9,%edi
mov    $0x2b,%esi
mov    $0x31,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xec(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0xe8(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xe8(%rbp),%edi
mov    %eax,%esi
call   10f0 <Fractions_dec@plt>
mov    %eax,-0xe4(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0xe4(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0xe0(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xe0(%rbp),%edi
mov    %eax,%esi
call   10f0 <Fractions_dec@plt>
mov    %eax,-0xdc(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xdc(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x3,%edi
xor    %edx,%edx
mov    %edx,%esi
call   10e0 <Fractions_initFract@plt>
mov    %eax,-0xd8(%rbp)
mov    $0x3,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    -0xd8(%rbp),%edi
mov    %eax,%esi
call   10f0 <Fractions_dec@plt>
mov    %eax,-0xd4(%rbp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    -0xd4(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xd0(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    -0xd0(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0xcc(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0xcc(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xc4(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xc8(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    -0xc8(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    -0xc4(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xc0(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    -0xc0(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0xbc(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    -0xbc(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xb4(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xb8(%rbp)
mov    $0x0,%al
call   10a0 <Fractions_one@plt>
mov    -0xb8(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    -0xb4(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xac(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xb0(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0xb0(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    -0xac(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xa8(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0xa8(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0xa4(%rbp)
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    -0xa4(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0xa0(%rbp)
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    -0xa0(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0x9c(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    -0x9c(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x98(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x98(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0x94(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    -0x94(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x90(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x90(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x8c(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    -0x8c(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x84(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x88(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x88(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    -0x84(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x80(%rbp)
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    -0x80(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x7c(%rbp)
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    -0x7c(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x78(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x78(%rbp),%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,-0x74(%rbp)
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    -0x74(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x70(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x70(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x6c(%rbp)
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    -0x6c(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x64(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x68(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x68(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    -0x64(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x60(%rbp)
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    -0x60(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x5c(%rbp)
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    -0x5c(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,-0x58(%rbp)
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    -0x58(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x54(%rbp)
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    -0x54(%rbp),%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,%edi
call   1090 <Fractions_writeFract@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x50(%rbp)
mov    $0x6,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x50(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x4c(%rbp)
mov    $0x4,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x4c(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x48(%rbp)
mov    $0x4,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x48(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,-0x40(%rbp)
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x44(%rbp)
mov    $0x4,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x44(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    -0x40(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x5,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,-0x38(%rbp)
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x3c(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x3c(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    -0x38(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%edi
call   1100 <Fractions_tan@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x34(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x34(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1190 <Fractions_root6@plt>
mov    %eax,-0x30(%rbp)
mov    $0x0,%al
call   11a0 <Fractions_root2@plt>
mov    -0x30(%rbp),%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x0,%al
call   1120 <Fractions_two@plt>
mov    -0x2c(%rbp),%edi
mov    %eax,%esi
call   1050 <Fractions_power@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x28(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x28(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,-0x20(%rbp)
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x24(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x24(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    -0x20(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x1c(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x1c(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,-0x14(%rbp)
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x18(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x18(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    -0x14(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,-0x4(%rbp)
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0x10(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0x10(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,-0x8(%rbp)
mov    $0x0,%al
call   1150 <Fractions_pi@plt>
mov    %eax,-0xc(%rbp)
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    -0xc(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    -0x8(%rbp),%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    -0x4(%rbp),%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
mov    $0x0,%al
call   1070 <writeLn@plt>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<regressionTest>:
push   %rbp
push   %r14
push   %rbx
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %eax,%ebx
mov    $0x1,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1120 <Fractions_two@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %eax,%eax
call   1120 <Fractions_two@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
mov    $0x1,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
mov    $0x1,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1180 <Fractions_half@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x9,%esi
mov    $0x14,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x9,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
mov    $0x2,%edi
mov    $0x9,%esi
mov    $0x14,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x9,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,%ebx
mov    $0x9,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x3,%esi
mov    $0xa,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0xa,%esi
mov    $0x3,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x2,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,%ebx
mov    $0x3,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x6,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x32,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %eax,%ebx
mov    $0x64,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%edi
call   1130 <Fractions_reciprocal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1030 <Fractions_inc@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x64,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x16,%esi
mov    $0x7,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x16,%esi
mov    $0x7,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
mov    $0x9,%edi
mov    $0x2b,%esi
mov    $0x31,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10f0 <Fractions_dec@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10f0 <Fractions_dec@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x3,%edi
xor    %esi,%esi
xor    %edx,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%ebx
mov    $0x3,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10f0 <Fractions_dec@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <Fractions_initFract@plt>
mov    %eax,%edi
call   11c0 <Fractions_negate@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   10a0 <Fractions_one@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebp
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebp
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1110 <Fractions_add@plt>
mov    %eax,%ebx
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %edi,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebp
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
mov    $0xfffffffe,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
mov    $0x1,%edi
call   1040 <Fractions_integer@plt>
mov    %eax,%ebx
mov    $0xffffffff,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
mov    $0x2,%edi
call   1040 <Fractions_integer@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1170 <Fractions_isEqual@plt>
mov    %eax,%edi
call   1080 <Assertion_Assert@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%edi
call   1090 <Fractions_writeFract@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0x6,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0x4,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0x4,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebp
mov    $0x4,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
mov    $0x5,%edi
call   1060 <Fractions_cardinal@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebp
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%edi
call   1100 <Fractions_tan@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1190 <Fractions_root6@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   11a0 <Fractions_root2@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10c0 <Fractions_sub@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1120 <Fractions_two@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1050 <Fractions_power@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebp
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
call   1070 <writeLn@plt>
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebp
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebp
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1150 <Fractions_pi@plt>
mov    %eax,%ebx
mov    $0xc,%edi
call   1060 <Fractions_cardinal@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   11b0 <Fractions_sin@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10b0 <Fractions_mult@plt>
mov    %r14d,%edi
mov    %eax,%esi
call   1140 <Fractions_div@plt>
mov    %eax,%edi
call   1160 <Fractions_simplify@plt>
mov    %eax,%edi
call   10d0 <pf@plt>
xor    %eax,%eax
pop    %rbx
pop    %r14
pop    %rbp
jmp    1070 <writeLn@plt>

LLVM IR (-O0):
define void @regressionTest() {
%1 = call i32 (...) @Fractions_half()
%2 = call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%3 = call i32 @Fractions_sub(i32 %1, i32 %2)
%4 = call i32 (...) @Fractions_one()
%5 = call i32 @Fractions_negate(i32 %4)
%6 = call i32 @Fractions_isEqual(i32 %3, i32 %5)
%7 = call i32 @Assertion_Assert(i32 %6)
%8 = call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%9 = call i32 (...) @Fractions_half()
%10 = call i32 @Fractions_sub(i32 %8, i32 %9)
%11 = call i32 (...) @Fractions_one()
%12 = call i32 @Fractions_isEqual(i32 %10, i32 %11)
%13 = call i32 @Assertion_Assert(i32 %12)
%14 = call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%15 = call i32 (...) @Fractions_half()
%16 = call i32 @Fractions_negate(i32 %15)
%17 = call i32 @Fractions_sub(i32 %14, i32 %16)
%18 = call i32 (...) @Fractions_two()
%19 = call i32 @Fractions_isEqual(i32 %17, i32 %18)
%20 = call i32 @Assertion_Assert(i32 %19)
%21 = call i32 (...) @Fractions_two()
%22 = call i32 @Fractions_negate(i32 %21)
%23 = call i32 (...) @Fractions_half()
%24 = call i32 @Fractions_negate(i32 %23)
%25 = call i32 @Fractions_sub(i32 %22, i32 %24)
%26 = call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%27 = call i32 @Fractions_negate(i32 %26)
%28 = call i32 @Fractions_isEqual(i32 %25, i32 %27)
%29 = call i32 @Assertion_Assert(i32 %28)
%30 = call i32 (...) @Fractions_one()
%31 = call i32 @Fractions_negate(i32 %30)
%32 = call i32 (...) @Fractions_half()
%33 = call i32 @Fractions_negate(i32 %32)
%34 = call i32 @Fractions_add(i32 %31, i32 %33)
%35 = call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%36 = call i32 @Fractions_negate(i32 %35)
%37 = call i32 @Fractions_isEqual(i32 %34, i32 %36)
%38 = call i32 @Assertion_Assert(i32 %37)
%39 = call i32 (...) @Fractions_half()
%40 = call i32 @Fractions_negate(i32 %39)
%41 = call i32 (...) @Fractions_half()
%42 = call i32 @Fractions_negate(i32 %41)
%43 = call i32 @Fractions_add(i32 %40, i32 %42)
%44 = call i32 @Fractions_integer(i32 -1)
%45 = call i32 @Fractions_isEqual(i32 %43, i32 %44)
%46 = call i32 @Assertion_Assert(i32 %45)
%47 = call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%48 = call i32 @Fractions_initFract(i32 0, i32 1, i32 5)
%49 = call i32 @Fractions_add(i32 %47, i32 %48)
%50 = call i32 @Fractions_initFract(i32 0, i32 9, i32 20)
%51 = call i32 @Fractions_isEqual(i32 %49, i32 %50)
%52 = call i32 @Assertion_Assert(i32 %51)
%53 = call i32 @Fractions_initFract(i32 0, i32 9, i32 4)
%54 = call i32 @Fractions_initFract(i32 0, i32 1, i32 5)
%55 = call i32 @Fractions_add(i32 %53, i32 %54)
%56 = call i32 @Fractions_initFract(i32 2, i32 9, i32 20)
%57 = call i32 @Fractions_isEqual(i32 %55, i32 %56)
%58 = call i32 @Assertion_Assert(i32 %57)
%59 = call i32 @Fractions_initFract(i32 0, i32 1, i32 9)
%60 = call i32 @Fractions_reciprocal(i32 %59)
%61 = call i32 @Fractions_cardinal(i32 9)
%62 = call i32 @Fractions_isEqual(i32 %60, i32 %61)
%63 = call i32 @Assertion_Assert(i32 %62)
%64 = call i32 @Fractions_initFract(i32 0, i32 3, i32 10)
%65 = call i32 @Fractions_reciprocal(i32 %64)
%66 = call i32 @Fractions_initFract(i32 0, i32 10, i32 3)
%67 = call i32 @Fractions_isEqual(i32 %65, i32 %66)
%68 = call i32 @Assertion_Assert(i32 %67)
%69 = call i32 (...) @Fractions_one()
%70 = call i32 @Fractions_reciprocal(i32 %69)
%71 = call i32 (...) @Fractions_one()
%72 = call i32 @Fractions_isEqual(i32 %70, i32 %71)
%73 = call i32 @Assertion_Assert(i32 %72)
%74 = call i32 @Fractions_cardinal(i32 2)
%75 = call i32 @Fractions_reciprocal(i32 %74)
%76 = call i32 @Fractions_cardinal(i32 3)
%77 = call i32 @Fractions_reciprocal(i32 %76)
%78 = call i32 @Fractions_mult(i32 %75, i32 %77)
%79 = call i32 @Fractions_initFract(i32 0, i32 1, i32 6)
%80 = call i32 @Fractions_isEqual(i32 %78, i32 %79)
%81 = call i32 @Assertion_Assert(i32 %80)
%82 = call i32 @Fractions_cardinal(i32 50)
%83 = call i32 @Fractions_reciprocal(i32 %82)
%84 = call i32 @Fractions_cardinal(i32 100)
%85 = call i32 @Fractions_reciprocal(i32 %84)
%86 = call i32 @Fractions_inc(i32 %83, i32 %85)
%87 = call i32 @Fractions_initFract(i32 0, i32 3, i32 100)
%88 = call i32 @Fractions_isEqual(i32 %86, i32 %87)
%89 = call i32 @Assertion_Assert(i32 %88)
%90 = call i32 @Fractions_initFract(i32 0, i32 22, i32 7)
%91 = call i32 @Fractions_initFract(i32 0, i32 22, i32 7)
%92 = call i32 @Fractions_mult(i32 %90, i32 %91)
%93 = call i32 @Fractions_initFract(i32 9, i32 43, i32 49)
%94 = call i32 @Fractions_isEqual(i32 %92, i32 %93)
%95 = call i32 @Assertion_Assert(i32 %94)
%96 = call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%97 = call i32 @Fractions_initFract(i32 0, i32 1, i32 2)
%98 = call i32 @Fractions_dec(i32 %96, i32 %97)
%99 = call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%100 = call i32 @Fractions_negate(i32 %99)
%101 = call i32 @Fractions_isEqual(i32 %98, i32 %100)
%102 = call i32 @Assertion_Assert(i32 %101)
%103 = call i32 @Fractions_initFract(i32 0, i32 1, i32 2)
%104 = call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%105 = call i32 @Fractions_dec(i32 %103, i32 %104)
%106 = call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%107 = call i32 @Fractions_isEqual(i32 %105, i32 %106)
%108 = call i32 @Assertion_Assert(i32 %107)
%109 = call i32 @Fractions_initFract(i32 3, i32 0, i32 0)
%110 = call i32 @Fractions_initFract(i32 3, i32 1, i32 4)
%111 = call i32 @Fractions_dec(i32 %109, i32 %110)
%112 = call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%113 = call i32 @Fractions_negate(i32 %112)
%114 = call i32 @Fractions_isEqual(i32 %111, i32 %113)
%115 = call i32 @Assertion_Assert(i32 %114)
%116 = call i32 @Fractions_integer(i32 -1)
%117 = call i32 (...) @Fractions_one()
%118 = call i32 @Fractions_mult(i32 %116, i32 %117)
%119 = call i32 @Fractions_integer(i32 -1)
%120 = call i32 @Fractions_isEqual(i32 %118, i32 %119)
%121 = call i32 @Assertion_Assert(i32 %120)
%122 = call i32 @Fractions_integer(i32 -1)
%123 = call i32 @Fractions_integer(i32 -1)
%124 = call i32 (...) @Fractions_one()
%125 = call i32 @Fractions_mult(i32 %123, i32 %124)
%126 = call i32 @Fractions_isEqual(i32 %122, i32 %125)
%127 = call i32 @Assertion_Assert(i32 %126)
%128 = call i32 @Fractions_integer(i32 -2)
%129 = call i32 (...) @Fractions_one()
%130 = call i32 @Fractions_mult(i32 %128, i32 %129)
%131 = call i32 @Fractions_integer(i32 -2)
%132 = call i32 @Fractions_isEqual(i32 %130, i32 %131)
%133 = call i32 @Assertion_Assert(i32 %132)
%134 = call i32 @Fractions_integer(i32 -2)
%135 = call i32 @Fractions_integer(i32 -2)
%136 = call i32 (...) @Fractions_one()
%137 = call i32 @Fractions_mult(i32 %135, i32 %136)
%138 = call i32 @Fractions_isEqual(i32 %134, i32 %137)
%139 = call i32 @Assertion_Assert(i32 %138)
%140 = call i32 @Fractions_integer(i32 2)
%141 = call i32 @Fractions_integer(i32 -2)
%142 = call i32 @Fractions_integer(i32 -1)
%143 = call i32 @Fractions_mult(i32 %141, i32 %142)
%144 = call i32 @Fractions_isEqual(i32 %140, i32 %143)
%145 = call i32 @Assertion_Assert(i32 %144)
%146 = call i32 @Fractions_integer(i32 -2)
%147 = call i32 @Fractions_integer(i32 -1)
%148 = call i32 @Fractions_mult(i32 %146, i32 %147)
%149 = call i32 @Fractions_integer(i32 2)
%150 = call i32 @Fractions_isEqual(i32 %148, i32 %149)
%151 = call i32 @Assertion_Assert(i32 %150)
%152 = call i32 @Fractions_integer(i32 -2)
%153 = call i32 @Fractions_integer(i32 1)
%154 = call i32 @Fractions_mult(i32 %152, i32 %153)
%155 = call i32 @Fractions_integer(i32 -2)
%156 = call i32 @Fractions_isEqual(i32 %154, i32 %155)
%157 = call i32 @Assertion_Assert(i32 %156)
%158 = call i32 @Fractions_integer(i32 2)
%159 = call i32 @Fractions_integer(i32 -1)
%160 = call i32 @Fractions_mult(i32 %158, i32 %159)
%161 = call i32 @Fractions_integer(i32 -2)
%162 = call i32 @Fractions_isEqual(i32 %160, i32 %161)
%163 = call i32 @Assertion_Assert(i32 %162)
%164 = call i32 @Fractions_integer(i32 -1)
%165 = call i32 @Fractions_integer(i32 -1)
%166 = call i32 @Fractions_add(i32 %164, i32 %165)
%167 = call i32 @Fractions_integer(i32 -2)
%168 = call i32 @Fractions_isEqual(i32 %166, i32 %167)
%169 = call i32 @Assertion_Assert(i32 %168)
%170 = call i32 @Fractions_integer(i32 -2)
%171 = call i32 @Fractions_integer(i32 -1)
%172 = call i32 @Fractions_integer(i32 -1)
%173 = call i32 @Fractions_add(i32 %171, i32 %172)
%174 = call i32 @Fractions_isEqual(i32 %170, i32 %173)
%175 = call i32 @Assertion_Assert(i32 %174)
%176 = call i32 @Fractions_integer(i32 -1)
%177 = call i32 @Fractions_integer(i32 1)
%178 = call i32 @Fractions_add(i32 %176, i32 %177)
%179 = call i32 @Fractions_integer(i32 0)
%180 = call i32 @Fractions_isEqual(i32 %178, i32 %179)
%181 = call i32 @Assertion_Assert(i32 %180)
%182 = call i32 @Fractions_integer(i32 1)
%183 = call i32 @Fractions_integer(i32 -1)
%184 = call i32 @Fractions_add(i32 %182, i32 %183)
%185 = call i32 @Fractions_integer(i32 0)
%186 = call i32 @Fractions_isEqual(i32 %184, i32 %185)
%187 = call i32 @Assertion_Assert(i32 %186)
%188 = call i32 @Fractions_integer(i32 -1)
%189 = call i32 @Fractions_integer(i32 -1)
%190 = call i32 @Fractions_sub(i32 %188, i32 %189)
%191 = call i32 @Fractions_integer(i32 0)
%192 = call i32 @Fractions_isEqual(i32 %190, i32 %191)
%193 = call i32 @Assertion_Assert(i32 %192)
%194 = call i32 @Fractions_integer(i32 0)
%195 = call i32 @Fractions_integer(i32 -1)
%196 = call i32 @Fractions_integer(i32 -1)
%197 = call i32 @Fractions_sub(i32 %195, i32 %196)
%198 = call i32 @Fractions_isEqual(i32 %194, i32 %197)
%199 = call i32 @Assertion_Assert(i32 %198)
%200 = call i32 @Fractions_integer(i32 -1)
%201 = call i32 @Fractions_integer(i32 1)
%202 = call i32 @Fractions_sub(i32 %200, i32 %201)
%203 = call i32 @Fractions_integer(i32 -2)
%204 = call i32 @Fractions_isEqual(i32 %202, i32 %203)
%205 = call i32 @Assertion_Assert(i32 %204)
%206 = call i32 @Fractions_integer(i32 1)
%207 = call i32 @Fractions_integer(i32 -1)
%208 = call i32 @Fractions_sub(i32 %206, i32 %207)
%209 = call i32 @Fractions_integer(i32 2)
%210 = call i32 @Fractions_isEqual(i32 %208, i32 %209)
%211 = call i32 @Assertion_Assert(i32 %210)
%212 = call i32 (...) @Fractions_pi()
%213 = call i32 @Fractions_writeFract(i32 %212)
%214 = call i32 (...) @writeLn()
%215 = call i32 (...) @Fractions_pi()
%216 = call i32 @Fractions_sin(i32 %215)
%217 = call i32 @Fractions_simplify(i32 %216)
%218 = call i32 @pf(i32 %217)
%219 = call i32 (...) @writeLn()
%220 = call i32 (...) @Fractions_pi()
%221 = call i32 @Fractions_cardinal(i32 6)
%222 = call i32 @Fractions_div(i32 %220, i32 %221)
%223 = call i32 @Fractions_sin(i32 %222)
%224 = call i32 @Fractions_simplify(i32 %223)
%225 = call i32 @pf(i32 %224)
%226 = call i32 (...) @writeLn()
%227 = call i32 (...) @Fractions_pi()
%228 = call i32 @Fractions_cardinal(i32 4)
%229 = call i32 @Fractions_div(i32 %227, i32 %228)
%230 = call i32 @Fractions_sin(i32 %229)
%231 = call i32 @Fractions_simplify(i32 %230)
%232 = call i32 @pf(i32 %231)
%233 = call i32 (...) @writeLn()
%234 = call i32 (...) @Fractions_pi()
%235 = call i32 @Fractions_cardinal(i32 4)
%236 = call i32 @Fractions_div(i32 %234, i32 %235)
%237 = call i32 @Fractions_sin(i32 %236)
%238 = call i32 (...) @Fractions_pi()
%239 = call i32 @Fractions_cardinal(i32 4)
%240 = call i32 @Fractions_div(i32 %238, i32 %239)
%241 = call i32 @Fractions_sin(i32 %240)
%242 = call i32 @Fractions_mult(i32 %237, i32 %241)
%243 = call i32 @Fractions_simplify(i32 %242)
%244 = call i32 @pf(i32 %243)
%245 = call i32 (...) @writeLn()
%246 = call i32 @Fractions_cardinal(i32 5)
%247 = call i32 (...) @Fractions_pi()
%248 = call i32 @Fractions_cardinal(i32 12)
%249 = call i32 @Fractions_div(i32 %247, i32 %248)
%250 = call i32 @Fractions_mult(i32 %246, i32 %249)
%251 = call i32 @Fractions_tan(i32 %250)
%252 = call i32 @Fractions_simplify(i32 %251)
%253 = call i32 @pf(i32 %252)
%254 = call i32 (...) @writeLn()
%255 = call i32 (...) @Fractions_pi()
%256 = call i32 @Fractions_cardinal(i32 12)
%257 = call i32 @Fractions_div(i32 %255, i32 %256)
%258 = call i32 @Fractions_sin(i32 %257)
%259 = call i32 @Fractions_simplify(i32 %258)
%260 = call i32 @pf(i32 %259)
%261 = call i32 (...) @writeLn()
%262 = call i32 (...) @Fractions_root6()
%263 = call i32 (...) @Fractions_root2()
%264 = call i32 @Fractions_sub(i32 %262, i32 %263)
%265 = call i32 (...) @Fractions_two()
%266 = call i32 @Fractions_power(i32 %264, i32 %265)
%267 = call i32 @Fractions_simplify(i32 %266)
%268 = call i32 @pf(i32 %267)
%269 = call i32 (...) @writeLn()
%270 = call i32 (...) @Fractions_pi()
%271 = call i32 @Fractions_cardinal(i32 12)
%272 = call i32 @Fractions_div(i32 %270, i32 %271)
%273 = call i32 @Fractions_sin(i32 %272)
%274 = call i32 (...) @Fractions_pi()
%275 = call i32 @Fractions_cardinal(i32 12)
%276 = call i32 @Fractions_div(i32 %274, i32 %275)
%277 = call i32 @Fractions_sin(i32 %276)
%278 = call i32 @Fractions_mult(i32 %273, i32 %277)
%279 = call i32 @Fractions_simplify(i32 %278)
%280 = call i32 @pf(i32 %279)
%281 = call i32 (...) @writeLn()
%282 = call i32 (...) @Fractions_pi()
%283 = call i32 @Fractions_cardinal(i32 12)
%284 = call i32 @Fractions_div(i32 %282, i32 %283)
%285 = call i32 @Fractions_sin(i32 %284)
%286 = call i32 (...) @Fractions_pi()
%287 = call i32 @Fractions_cardinal(i32 12)
%288 = call i32 @Fractions_div(i32 %286, i32 %287)
%289 = call i32 @Fractions_sin(i32 %288)
%290 = call i32 @Fractions_mult(i32 %285, i32 %289)
%291 = call i32 (...) @Fractions_pi()
%292 = call i32 @Fractions_cardinal(i32 12)
%293 = call i32 @Fractions_div(i32 %291, i32 %292)
%294 = call i32 @Fractions_sin(i32 %293)
%295 = call i32 (...) @Fractions_pi()
%296 = call i32 @Fractions_cardinal(i32 12)
%297 = call i32 @Fractions_div(i32 %295, i32 %296)
%298 = call i32 @Fractions_sin(i32 %297)
%299 = call i32 @Fractions_mult(i32 %294, i32 %298)
%300 = call i32 @Fractions_div(i32 %290, i32 %299)
%301 = call i32 @Fractions_simplify(i32 %300)
%302 = call i32 @pf(i32 %301)
%303 = call i32 (...) @writeLn()
ret void
}

LLVM IR (-O2):
define void @regressionTest() {
%1 = tail call i32 (...) @Fractions_half()
%2 = tail call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%3 = tail call i32 @Fractions_sub(i32 %1, i32 %2)
%4 = tail call i32 (...) @Fractions_one()
%5 = tail call i32 @Fractions_negate(i32 %4)
%6 = tail call i32 @Fractions_isEqual(i32 %3, i32 %5)
%7 = tail call i32 @Assertion_Assert(i32 %6)
%8 = tail call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%9 = tail call i32 (...) @Fractions_half()
%10 = tail call i32 @Fractions_sub(i32 %8, i32 %9)
%11 = tail call i32 (...) @Fractions_one()
%12 = tail call i32 @Fractions_isEqual(i32 %10, i32 %11)
%13 = tail call i32 @Assertion_Assert(i32 %12)
%14 = tail call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%15 = tail call i32 (...) @Fractions_half()
%16 = tail call i32 @Fractions_negate(i32 %15)
%17 = tail call i32 @Fractions_sub(i32 %14, i32 %16)
%18 = tail call i32 (...) @Fractions_two()
%19 = tail call i32 @Fractions_isEqual(i32 %17, i32 %18)
%20 = tail call i32 @Assertion_Assert(i32 %19)
%21 = tail call i32 (...) @Fractions_two()
%22 = tail call i32 @Fractions_negate(i32 %21)
%23 = tail call i32 (...) @Fractions_half()
%24 = tail call i32 @Fractions_negate(i32 %23)
%25 = tail call i32 @Fractions_sub(i32 %22, i32 %24)
%26 = tail call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%27 = tail call i32 @Fractions_negate(i32 %26)
%28 = tail call i32 @Fractions_isEqual(i32 %25, i32 %27)
%29 = tail call i32 @Assertion_Assert(i32 %28)
%30 = tail call i32 (...) @Fractions_one()
%31 = tail call i32 @Fractions_negate(i32 %30)
%32 = tail call i32 (...) @Fractions_half()
%33 = tail call i32 @Fractions_negate(i32 %32)
%34 = tail call i32 @Fractions_add(i32 %31, i32 %33)
%35 = tail call i32 @Fractions_initFract(i32 1, i32 1, i32 2)
%36 = tail call i32 @Fractions_negate(i32 %35)
%37 = tail call i32 @Fractions_isEqual(i32 %34, i32 %36)
%38 = tail call i32 @Assertion_Assert(i32 %37)
%39 = tail call i32 (...) @Fractions_half()
%40 = tail call i32 @Fractions_negate(i32 %39)
%41 = tail call i32 (...) @Fractions_half()
%42 = tail call i32 @Fractions_negate(i32 %41)
%43 = tail call i32 @Fractions_add(i32 %40, i32 %42)
%44 = tail call i32 @Fractions_integer(i32 -1)
%45 = tail call i32 @Fractions_isEqual(i32 %43, i32 %44)
%46 = tail call i32 @Assertion_Assert(i32 %45)
%47 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%48 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 5)
%49 = tail call i32 @Fractions_add(i32 %47, i32 %48)
%50 = tail call i32 @Fractions_initFract(i32 0, i32 9, i32 20)
%51 = tail call i32 @Fractions_isEqual(i32 %49, i32 %50)
%52 = tail call i32 @Assertion_Assert(i32 %51)
%53 = tail call i32 @Fractions_initFract(i32 0, i32 9, i32 4)
%54 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 5)
%55 = tail call i32 @Fractions_add(i32 %53, i32 %54)
%56 = tail call i32 @Fractions_initFract(i32 2, i32 9, i32 20)
%57 = tail call i32 @Fractions_isEqual(i32 %55, i32 %56)
%58 = tail call i32 @Assertion_Assert(i32 %57)
%59 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 9)
%60 = tail call i32 @Fractions_reciprocal(i32 %59)
%61 = tail call i32 @Fractions_cardinal(i32 9)
%62 = tail call i32 @Fractions_isEqual(i32 %60, i32 %61)
%63 = tail call i32 @Assertion_Assert(i32 %62)
%64 = tail call i32 @Fractions_initFract(i32 0, i32 3, i32 10)
%65 = tail call i32 @Fractions_reciprocal(i32 %64)
%66 = tail call i32 @Fractions_initFract(i32 0, i32 10, i32 3)
%67 = tail call i32 @Fractions_isEqual(i32 %65, i32 %66)
%68 = tail call i32 @Assertion_Assert(i32 %67)
%69 = tail call i32 (...) @Fractions_one()
%70 = tail call i32 @Fractions_reciprocal(i32 %69)
%71 = tail call i32 (...) @Fractions_one()
%72 = tail call i32 @Fractions_isEqual(i32 %70, i32 %71)
%73 = tail call i32 @Assertion_Assert(i32 %72)
%74 = tail call i32 @Fractions_cardinal(i32 2)
%75 = tail call i32 @Fractions_reciprocal(i32 %74)
%76 = tail call i32 @Fractions_cardinal(i32 3)
%77 = tail call i32 @Fractions_reciprocal(i32 %76)
%78 = tail call i32 @Fractions_mult(i32 %75, i32 %77)
%79 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 6)
%80 = tail call i32 @Fractions_isEqual(i32 %78, i32 %79)
%81 = tail call i32 @Assertion_Assert(i32 %80)
%82 = tail call i32 @Fractions_cardinal(i32 50)
%83 = tail call i32 @Fractions_reciprocal(i32 %82)
%84 = tail call i32 @Fractions_cardinal(i32 100)
%85 = tail call i32 @Fractions_reciprocal(i32 %84)
%86 = tail call i32 @Fractions_inc(i32 %83, i32 %85)
%87 = tail call i32 @Fractions_initFract(i32 0, i32 3, i32 100)
%88 = tail call i32 @Fractions_isEqual(i32 %86, i32 %87)
%89 = tail call i32 @Assertion_Assert(i32 %88)
%90 = tail call i32 @Fractions_initFract(i32 0, i32 22, i32 7)
%91 = tail call i32 @Fractions_initFract(i32 0, i32 22, i32 7)
%92 = tail call i32 @Fractions_mult(i32 %90, i32 %91)
%93 = tail call i32 @Fractions_initFract(i32 9, i32 43, i32 49)
%94 = tail call i32 @Fractions_isEqual(i32 %92, i32 %93)
%95 = tail call i32 @Assertion_Assert(i32 %94)
%96 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%97 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 2)
%98 = tail call i32 @Fractions_dec(i32 %96, i32 %97)
%99 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%100 = tail call i32 @Fractions_negate(i32 %99)
%101 = tail call i32 @Fractions_isEqual(i32 %98, i32 %100)
%102 = tail call i32 @Assertion_Assert(i32 %101)
%103 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 2)
%104 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%105 = tail call i32 @Fractions_dec(i32 %103, i32 %104)
%106 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%107 = tail call i32 @Fractions_isEqual(i32 %105, i32 %106)
%108 = tail call i32 @Assertion_Assert(i32 %107)
%109 = tail call i32 @Fractions_initFract(i32 3, i32 0, i32 0)
%110 = tail call i32 @Fractions_initFract(i32 3, i32 1, i32 4)
%111 = tail call i32 @Fractions_dec(i32 %109, i32 %110)
%112 = tail call i32 @Fractions_initFract(i32 0, i32 1, i32 4)
%113 = tail call i32 @Fractions_negate(i32 %112)
%114 = tail call i32 @Fractions_isEqual(i32 %111, i32 %113)
%115 = tail call i32 @Assertion_Assert(i32 %114)
%116 = tail call i32 @Fractions_integer(i32 -1)
%117 = tail call i32 (...) @Fractions_one()
%118 = tail call i32 @Fractions_mult(i32 %116, i32 %117)
%119 = tail call i32 @Fractions_integer(i32 -1)
%120 = tail call i32 @Fractions_isEqual(i32 %118, i32 %119)
%121 = tail call i32 @Assertion_Assert(i32 %120)
%122 = tail call i32 @Fractions_integer(i32 -1)
%123 = tail call i32 @Fractions_integer(i32 -1)
%124 = tail call i32 (...) @Fractions_one()
%125 = tail call i32 @Fractions_mult(i32 %123, i32 %124)
%126 = tail call i32 @Fractions_isEqual(i32 %122, i32 %125)
%127 = tail call i32 @Assertion_Assert(i32 %126)
%128 = tail call i32 @Fractions_integer(i32 -2)
%129 = tail call i32 (...) @Fractions_one()
%130 = tail call i32 @Fractions_mult(i32 %128, i32 %129)
%131 = tail call i32 @Fractions_integer(i32 -2)
%132 = tail call i32 @Fractions_isEqual(i32 %130, i32 %131)
%133 = tail call i32 @Assertion_Assert(i32 %132)
%134 = tail call i32 @Fractions_integer(i32 -2)
%135 = tail call i32 @Fractions_integer(i32 -2)
%136 = tail call i32 (...) @Fractions_one()
%137 = tail call i32 @Fractions_mult(i32 %135, i32 %136)
%138 = tail call i32 @Fractions_isEqual(i32 %134, i32 %137)
%139 = tail call i32 @Assertion_Assert(i32 %138)
%140 = tail call i32 @Fractions_integer(i32 2)
%141 = tail call i32 @Fractions_integer(i32 -2)
%142 = tail call i32 @Fractions_integer(i32 -1)
%143 = tail call i32 @Fractions_mult(i32 %141, i32 %142)
%144 = tail call i32 @Fractions_isEqual(i32 %140, i32 %143)
%145 = tail call i32 @Assertion_Assert(i32 %144)
%146 = tail call i32 @Fractions_integer(i32 -2)
%147 = tail call i32 @Fractions_integer(i32 -1)
%148 = tail call i32 @Fractions_mult(i32 %146, i32 %147)
%149 = tail call i32 @Fractions_integer(i32 2)
%150 = tail call i32 @Fractions_isEqual(i32 %148, i32 %149)
%151 = tail call i32 @Assertion_Assert(i32 %150)
%152 = tail call i32 @Fractions_integer(i32 -2)
%153 = tail call i32 @Fractions_integer(i32 1)
%154 = tail call i32 @Fractions_mult(i32 %152, i32 %153)
%155 = tail call i32 @Fractions_integer(i32 -2)
%156 = tail call i32 @Fractions_isEqual(i32 %154, i32 %155)
%157 = tail call i32 @Assertion_Assert(i32 %156)
%158 = tail call i32 @Fractions_integer(i32 2)
%159 = tail call i32 @Fractions_integer(i32 -1)
%160 = tail call i32 @Fractions_mult(i32 %158, i32 %159)
%161 = tail call i32 @Fractions_integer(i32 -2)
%162 = tail call i32 @Fractions_isEqual(i32 %160, i32 %161)
%163 = tail call i32 @Assertion_Assert(i32 %162)
%164 = tail call i32 @Fractions_integer(i32 -1)
%165 = tail call i32 @Fractions_integer(i32 -1)
%166 = tail call i32 @Fractions_add(i32 %164, i32 %165)
%167 = tail call i32 @Fractions_integer(i32 -2)
%168 = tail call i32 @Fractions_isEqual(i32 %166, i32 %167)
%169 = tail call i32 @Assertion_Assert(i32 %168)
%170 = tail call i32 @Fractions_integer(i32 -2)
%171 = tail call i32 @Fractions_integer(i32 -1)
%172 = tail call i32 @Fractions_integer(i32 -1)
%173 = tail call i32 @Fractions_add(i32 %171, i32 %172)
%174 = tail call i32 @Fractions_isEqual(i32 %170, i32 %173)
%175 = tail call i32 @Assertion_Assert(i32 %174)
%176 = tail call i32 @Fractions_integer(i32 -1)
%177 = tail call i32 @Fractions_integer(i32 1)
%178 = tail call i32 @Fractions_add(i32 %176, i32 %177)
%179 = tail call i32 @Fractions_integer(i32 0)
%180 = tail call i32 @Fractions_isEqual(i32 %178, i32 %179)
%181 = tail call i32 @Assertion_Assert(i32 %180)
%182 = tail call i32 @Fractions_integer(i32 1)
%183 = tail call i32 @Fractions_integer(i32 -1)
%184 = tail call i32 @Fractions_add(i32 %182, i32 %183)
%185 = tail call i32 @Fractions_integer(i32 0)
%186 = tail call i32 @Fractions_isEqual(i32 %184, i32 %185)
%187 = tail call i32 @Assertion_Assert(i32 %186)
%188 = tail call i32 @Fractions_integer(i32 -1)
%189 = tail call i32 @Fractions_integer(i32 -1)
%190 = tail call i32 @Fractions_sub(i32 %188, i32 %189)
%191 = tail call i32 @Fractions_integer(i32 0)
%192 = tail call i32 @Fractions_isEqual(i32 %190, i32 %191)
%193 = tail call i32 @Assertion_Assert(i32 %192)
%194 = tail call i32 @Fractions_integer(i32 0)
%195 = tail call i32 @Fractions_integer(i32 -1)
%196 = tail call i32 @Fractions_integer(i32 -1)
%197 = tail call i32 @Fractions_sub(i32 %195, i32 %196)
%198 = tail call i32 @Fractions_isEqual(i32 %194, i32 %197)
%199 = tail call i32 @Assertion_Assert(i32 %198)
%200 = tail call i32 @Fractions_integer(i32 -1)
%201 = tail call i32 @Fractions_integer(i32 1)
%202 = tail call i32 @Fractions_sub(i32 %200, i32 %201)
%203 = tail call i32 @Fractions_integer(i32 -2)
%204 = tail call i32 @Fractions_isEqual(i32 %202, i32 %203)
%205 = tail call i32 @Assertion_Assert(i32 %204)
%206 = tail call i32 @Fractions_integer(i32 1)
%207 = tail call i32 @Fractions_integer(i32 -1)
%208 = tail call i32 @Fractions_sub(i32 %206, i32 %207)
%209 = tail call i32 @Fractions_integer(i32 2)
%210 = tail call i32 @Fractions_isEqual(i32 %208, i32 %209)
%211 = tail call i32 @Assertion_Assert(i32 %210)
%212 = tail call i32 (...) @Fractions_pi()
%213 = tail call i32 @Fractions_writeFract(i32 %212)
%214 = tail call i32 (...) @writeLn()
%215 = tail call i32 (...) @Fractions_pi()
%216 = tail call i32 @Fractions_sin(i32 %215)
%217 = tail call i32 @Fractions_simplify(i32 %216)
%218 = tail call i32 @pf(i32 %217)
%219 = tail call i32 (...) @writeLn()
%220 = tail call i32 (...) @Fractions_pi()
%221 = tail call i32 @Fractions_cardinal(i32 6)
%222 = tail call i32 @Fractions_div(i32 %220, i32 %221)
%223 = tail call i32 @Fractions_sin(i32 %222)
%224 = tail call i32 @Fractions_simplify(i32 %223)
%225 = tail call i32 @pf(i32 %224)
%226 = tail call i32 (...) @writeLn()
%227 = tail call i32 (...) @Fractions_pi()
%228 = tail call i32 @Fractions_cardinal(i32 4)
%229 = tail call i32 @Fractions_div(i32 %227, i32 %228)
%230 = tail call i32 @Fractions_sin(i32 %229)
%231 = tail call i32 @Fractions_simplify(i32 %230)
%232 = tail call i32 @pf(i32 %231)
%233 = tail call i32 (...) @writeLn()
%234 = tail call i32 (...) @Fractions_pi()
%235 = tail call i32 @Fractions_cardinal(i32 4)
%236 = tail call i32 @Fractions_div(i32 %234, i32 %235)
%237 = tail call i32 @Fractions_sin(i32 %236)
%238 = tail call i32 (...) @Fractions_pi()
%239 = tail call i32 @Fractions_cardinal(i32 4)
%240 = tail call i32 @Fractions_div(i32 %238, i32 %239)
%241 = tail call i32 @Fractions_sin(i32 %240)
%242 = tail call i32 @Fractions_mult(i32 %237, i32 %241)
%243 = tail call i32 @Fractions_simplify(i32 %242)
%244 = tail call i32 @pf(i32 %243)
%245 = tail call i32 (...) @writeLn()
%246 = tail call i32 @Fractions_cardinal(i32 5)
%247 = tail call i32 (...) @Fractions_pi()
%248 = tail call i32 @Fractions_cardinal(i32 12)
%249 = tail call i32 @Fractions_div(i32 %247, i32 %248)
%250 = tail call i32 @Fractions_mult(i32 %246, i32 %249)
%251 = tail call i32 @Fractions_tan(i32 %250)
%252 = tail call i32 @Fractions_simplify(i32 %251)
%253 = tail call i32 @pf(i32 %252)
%254 = tail call i32 (...) @writeLn()
%255 = tail call i32 (...) @Fractions_pi()
%256 = tail call i32 @Fractions_cardinal(i32 12)
%257 = tail call i32 @Fractions_div(i32 %255, i32 %256)
%258 = tail call i32 @Fractions_sin(i32 %257)
%259 = tail call i32 @Fractions_simplify(i32 %258)
%260 = tail call i32 @pf(i32 %259)
%261 = tail call i32 (...) @writeLn()
%262 = tail call i32 (...) @Fractions_root6()
%263 = tail call i32 (...) @Fractions_root2()
%264 = tail call i32 @Fractions_sub(i32 %262, i32 %263)
%265 = tail call i32 (...) @Fractions_two()
%266 = tail call i32 @Fractions_power(i32 %264, i32 %265)
%267 = tail call i32 @Fractions_simplify(i32 %266)
%268 = tail call i32 @pf(i32 %267)
%269 = tail call i32 (...) @writeLn()
%270 = tail call i32 (...) @Fractions_pi()
%271 = tail call i32 @Fractions_cardinal(i32 12)
%272 = tail call i32 @Fractions_div(i32 %270, i32 %271)
%273 = tail call i32 @Fractions_sin(i32 %272)
%274 = tail call i32 (...) @Fractions_pi()
%275 = tail call i32 @Fractions_cardinal(i32 12)
%276 = tail call i32 @Fractions_div(i32 %274, i32 %275)
%277 = tail call i32 @Fractions_sin(i32 %276)
%278 = tail call i32 @Fractions_mult(i32 %273, i32 %277)
%279 = tail call i32 @Fractions_simplify(i32 %278)
%280 = tail call i32 @pf(i32 %279)
%281 = tail call i32 (...) @writeLn()
%282 = tail call i32 (...) @Fractions_pi()
%283 = tail call i32 @Fractions_cardinal(i32 12)
%284 = tail call i32 @Fractions_div(i32 %282, i32 %283)
%285 = tail call i32 @Fractions_sin(i32 %284)
%286 = tail call i32 (...) @Fractions_pi()
%287 = tail call i32 @Fractions_cardinal(i32 12)
%288 = tail call i32 @Fractions_div(i32 %286, i32 %287)
%289 = tail call i32 @Fractions_sin(i32 %288)
%290 = tail call i32 @Fractions_mult(i32 %285, i32 %289)
%291 = tail call i32 (...) @Fractions_pi()
%292 = tail call i32 @Fractions_cardinal(i32 12)
%293 = tail call i32 @Fractions_div(i32 %291, i32 %292)
%294 = tail call i32 @Fractions_sin(i32 %293)
%295 = tail call i32 (...) @Fractions_pi()
%296 = tail call i32 @Fractions_cardinal(i32 12)
%297 = tail call i32 @Fractions_div(i32 %295, i32 %296)
%298 = tail call i32 @Fractions_sin(i32 %297)
%299 = tail call i32 @Fractions_mult(i32 %294, i32 %298)
%300 = tail call i32 @Fractions_div(i32 %290, i32 %299)
%301 = tail call i32 @Fractions_simplify(i32 %300)
%302 = tail call i32 @pf(i32 %301)
%303 = tail call i32 (...) @writeLn()
ret void
}