assert_is_true(&a, "5 + x + 2 == 7 + x");
  assert_is_true(&a, "3 + x + 5 + x == 8 + 2 * x");
  assert_is_true(&a, "x + y + z + x + y + z == 2*x + 2*y + 2*z");
  assert_is_true(&a, "10 - x == 10 + x * -1");
  assert_is_true(&a, "10 + x == 10 + x * -1 * -1");
  assert_is_true(&a, "10 + x == 10 + x * -1 * -1");
  assert_is_true(&a, "10 == 100 / 10");

  printf("tests done\n");

#include "algebra-integer.inc"
#include "algebra-fraction.inc"

  // x + x -> 2x

  // x + x => 2x

    uint64_t product_values[2] = { pack_integer(2), lhs };

    uint64_t product_values[2];
    product_values[0] = LITERAL_TWO;
    product_values[1] = lhs;

  }
  // n • x + x => (n + 1) • x
  if(is_product(lhs) && get_list_count(lhs) == 2) {
    uint64_t num = get_index(a, lhs, 0);
    if(is_number(num)) {
      uint64_t var = get_index(a, lhs, 1);
      if(is_variable(var) && is_variable(rhs) && alias_str_same(unpack_variable(var), unpack_variable(rhs))) {
        uint64_t product_values[2];
        product_values[0] = number_add(a, num, LITERAL_ONE);
        product_values[1] = rhs;
        *merged = embed_product(a, 2, product_values);
        return true;
      }
    }
  }
  // x + n • x => (n + 1) • x
  if(is_product(rhs) && get_list_count(rhs) == 2) {
    uint64_t num = get_index(a, rhs, 0);
    if(is_number(num)) {
      uint64_t var = get_index(a, rhs, 1);
      if(is_variable(var) && is_variable(lhs) && alias_str_same(unpack_variable(var), unpack_variable(lhs))) {
        uint64_t product_values[2];
        product_values[0] = number_add(a, num, LITERAL_ONE);
        product_values[1] = lhs;
        *merged = embed_product(a, 2, product_values);
        return true;
      }
    }

    return pack_integer(0);

    return LITERAL_ZERO;

  if(new_count == 0) {
    return LITERAL_ZERO;
  } else if(new_count == 1) {
    return new_values[0];
  }

#define SIMPLIFY(TYPE, FN) static uint64_t TYPE##_simplify(struct solver_Algebra *a, uint64_t bits) FN

#define SIMPLIFY(TYPE, FN) static uint64_t simplify__##TYPE(struct solver_Algebra *a, uint64_t bits) FN

SIMPLE(integer)
SIMPLE(big_integer)

SIMPLE(smallint)
SIMPLE(largeint)

    return real_simplify(a, bits);

    return simplify__real(a, bits);

    return variable_simplify(a, bits);

    return simplify__variable(a, bits);

    return boolean_simplify(a, bits);

    return simplify__boolean(a, bits);

    return undefined_simplify(a, bits);
  case Tag_Integer:
    return integer_simplify(a, bits);
  case Tag_BigInteger:
    return big_integer_simplify(a, bits);

    return simplify__undefined(a, bits);
  case Tag_SmallInt:
    return simplify__smallint(a, bits);

    return fraction_simplify(a, bits);

    return simplify__fraction(a, bits);

    return power_simplify(a, bits);

    return simplify__power(a, bits);

    return sum_simplify(a, bits);

    return simplify__sum(a, bits);

    return product_simplify(a, bits);

    return simplify__product(a, bits);

    return equals_simplify(a, bits);

    return simplify__equals(a, bits);

    return not_equals_simplify(a, bits);

    return simplify__not_equals(a, bits);

    return less_than_simplify(a, bits);

    return simplify__less_than(a, bits);

    return greater_than_simplify(a, bits);

    return simplify__greater_than(a, bits);

  case Tag_Integer:
  case Tag_BigInteger:

  case Tag_SmallInt:
  case Tag_LargeInt:

static void show_integer(struct solver_Algebra *a, uint64_t bits) {
  printf("%i", unpack_integer(bits));

static void show__smallint(struct solver_Algebra *a, uint64_t bits) {
  printf("%li", unpack_smallint(bits));

static void show_big_integer(struct solver_Algebra *a, uint64_t bits) {
  printf("%p", unpack_big_integer(bits));

static void show__largeint(struct solver_Algebra *a, uint64_t bits) {
  // TODO

static void show_fraction(struct solver_Algebra *a, uint64_t bits) {

static void show__fraction(struct solver_Algebra *a, uint64_t bits) {

static void show_power(struct solver_Algebra *a, uint64_t bits) {

static void show__power(struct solver_Algebra *a, uint64_t bits) {

  printf("/");

  printf("^");

static void show_sum(struct solver_Algebra *a, uint64_t bits) {

static void show__sum(struct solver_Algebra *a, uint64_t bits) {

static void show_product(struct solver_Algebra *a, uint64_t bits) {

static void show__product(struct solver_Algebra *a, uint64_t bits) {

static void show_equals(struct solver_Algebra *a, uint64_t bits) {

static void show__equals(struct solver_Algebra *a, uint64_t bits) {

static void show_not_equals(struct solver_Algebra *a, uint64_t bits) {

static void show__not_equals(struct solver_Algebra *a, uint64_t bits) {

static void show_less_than(struct solver_Algebra *a, uint64_t bits) {

static void show__less_than(struct solver_Algebra *a, uint64_t bits) {

static void show_greater_than(struct solver_Algebra *a, uint64_t bits) {

static void show__greater_than(struct solver_Algebra *a, uint64_t bits) {

  case Tag_Integer:
    show_integer(a, bits);

  case Tag_SmallInt:
    show__smallint(a, bits);

  case Tag_BigInteger:
    show_big_integer(a, bits);

  case Tag_LargeInt:
    show__largeint(a, bits);

    show_fraction(a, bits);

    show__fraction(a, bits);

    show_power(a, bits);

    show__power(a, bits);

    show_sum(a, bits);

    show__sum(a, bits);

    show_product(a, bits);

    show__product(a, bits);

    show_equals(a, bits);

    show__equals(a, bits);

    show_not_equals(a, bits);

    show__not_equals(a, bits);

    show_less_than(a, bits);

    show__less_than(a, bits);

    show_greater_than(a, bits);

    show__greater_than(a, bits);

static bool product_merge_single_term(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs, uint64_t *merged) {
  if(is_number(lhs) && is_number(rhs)) {
    *merged = number_multiply(a, lhs, rhs);
    return true;
  }
  if(is_number(lhs) && lhs == LITERAL_ZERO) {
    *merged = LITERAL_ZERO;
    return true;
  }
  if(is_number(rhs) && rhs == LITERAL_ZERO) {
    *merged = LITERAL_ZERO;
    return true;
  }
  if(is_number(lhs) && lhs == LITERAL_ONE) {
    *merged = rhs;
    return true;
  }
  if(is_number(rhs) && rhs == LITERAL_ONE) {
    *merged = lhs;
    return true;
  }
  return false;
}

  if(count == 0) return pack_integer(0);

  uint64_t merged;
  if(count == 0) return LITERAL_ZERO;

    if(is_number(values[0]) && is_number(values[1])) {
      return number_multiply(a, values[0], values[1]);

    if(product_merge_single_term(a, values[0], values[1], &merged)) {
      return merged;
    }
  }
  uint32_t new_count = 0;
  uint64_t * new_values = alias_stack_allocation(sizeof(*new_values) * count, alignof(*new_values));
  for(uint32_t i = 0; i < count; i++) {
    uint32_t k;
    for(k = 0; k < new_count; k++) {
      if(product_merge_single_term(a, new_values[k], values[i], &merged)) {
        if(merged == LITERAL_ZERO) return LITERAL_ZERO;
        new_values[k] = merged;
        break;
      }
    }
    if(k == new_count) {
      if(values[i] == LITERAL_ZERO) return LITERAL_ZERO;
      new_values[new_count++] = values[i];
    }
  }
  if(new_count == 0) return LITERAL_ZERO;
  if(new_count == 1) return new_values[0];
  if(new_count == 2) {
    if(product_merge_single_term(a, new_values[0], new_values[1], &merged)) {
      return merged;

  tabula_qsort(new_values, new_count, sizeof(*new_values), qsort_term_compare, a);  

  product.count = count;
  product.index = embed_values(a, count, values);

  product.count = new_count;
  product.index = embed_values(a, new_count, new_values);

uint64_t solver_Algebra_power(struct solver_Algebra *a, uint64_t base, uint64_t exponent) {

static uint64_t embed_power(struct solver_Algebra *a, uint64_t base, uint64_t exponent) {
  if(is_number(base) && is_number(exponent)) {
    return number_power(a, base, exponent);
  }
  if(is_number(base) && base == LITERAL_ZERO)         return LITERAL_ZERO;
  if(is_number(base) && base == LITERAL_ONE)          return LITERAL_ONE;
  if(is_number(exponent) && exponent == LITERAL_ZERO) return LITERAL_ONE;
  if(is_number(exponent) && exponent == LITERAL_ONE)  return base;

uint64_t solver_Algebra_power(struct solver_Algebra *a, uint64_t base, uint64_t exponent) { 
  return embed_power(a, base, exponent);
}

static void Files_free(void) {
  for(uint32_t i = 0; i < _.num_files; i++) {
    if(_.files[i]->newlines != NULL) {
      free(_.files[i]->newlines);
    }
    free(_.files[i]);
  }
  if(_.files != NULL) {
    free(_.files);
  }
  _.last_location = 1;
  _.num_files = 0;
  _.files = NULL;
}

%type fraction { uint64_t }
fraction(O) ::= integer(N) SOLIDUS integer(D).                  { O = solver_Algebra_fraction(extra.a, N, D); }

//%type fraction { uint64_t }
//fraction(O) ::= integer(N) SOLIDUS integer(D).                  { O = solver_Algebra_fraction(extra.a, N, D); }

primary(O) ::= fraction(F).                                     { O = F; }

//primary(O) ::= fraction(F).                                     { O = F; }
%type unary { uint64_t }
unary(O) ::= MACRON unary(A).                                   { O = solver_Algebra_negate(extra.a, A); }
unary(O) ::= HYPHEN_MINUS unary(B).                             { O = solver_Algebra_negate(extra.a, B); }
unary(O) ::= primary(C).                                        { O = C; }

power(O) ::= primary(E).                                        { O = E; }

power(O) ::= unary(E).                                          { O = E; }

product_list(O) ::= product_list(A) SOLIDUS power(B).           { O = A; Values_add(&O, solver_Algebra_inverse(extra.a, B)); }

  Files_free();

  return is_integer(bits) || is_big_integer(bits) || is_fraction(bits) || is_real(bits);

  return is_smallint(bits) || is_largeint(bits) || is_fraction(bits) || is_real(bits);

static uint64_t integer_integer_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return pack_integer(unpack_integer(lhs) + unpack_integer(rhs));

static uint64_t number_add__smallint__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  int64_t l = unpack_smallint(lhs);
  int64_t r = unpack_smallint(rhs);
  int64_t c = l + r;
  return pack_smallint(c);

static uint64_t integer_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static uint64_t number_add__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

  case Tag_Integer:
    return integer_integer_add(a, lhs, rhs);

  case Tag_SmallInt:
    return number_add__smallint__smallint(a, lhs, rhs);

  case Tag_Integer:
    return integer_add(a, lhs, rhs);

  case Tag_SmallInt:
    return number_add__smallint(a, lhs, rhs);

static uint64_t number_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs);

static uint64_t integer_integer_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  // TODO big integer upgrade
  return pack_integer(unpack_integer(lhs) * unpack_integer(rhs));

static uint64_t number_multiply__smallint__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return pack_smallint(unpack_smallint(lhs) * unpack_smallint(rhs));

static uint64_t integer_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static uint64_t number_multiply__smallint__fraction(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  uint64_t n = get_car(a, rhs);
  uint64_t d = get_cdr(a, rhs);
  return solver_Algebra_fraction(a, number_multiply(a, lhs, n), d);
}
static uint64_t number_multiply__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

  case Tag_Integer:
    return integer_integer_multiply(a, lhs, rhs);

  case Tag_SmallInt:
    return number_multiply__smallint__smallint(a, lhs, rhs);
  case Tag_Fraction:
    return number_multiply__smallint__fraction(a, lhs, rhs);

  case Tag_Integer:
    return integer_multiply(a, lhs, rhs);

  case Tag_SmallInt:
    return number_multiply__smallint(a, lhs, rhs);

static int integer_integer_compare(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  // TODO big integer upgrade
  return unpack_integer(rhs) - unpack_integer(lhs);

static uint64_t number_power__smallint__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  int64_t base = unpack_smallint(lhs);
  int64_t exp = unpack_smallint(rhs);
  bool n = exp < 0;
  if(exp) {
    exp = -exp;
  }
  int32_t result = 1;
  for(;;) {
    if(exp & 1) {
      result *= base;
    }
    exp >>= 1;
    if(exp == 0) {
      break;
    }
    base *= base;
  }
  if(n) {
    return solver_Algebra_fraction(a, LITERAL_ONE, pack_smallint(result));
  } else {
    return pack_smallint(result);
  }

static int integer_compare(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static uint64_t number_power__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

  case Tag_Integer:
    return integer_integer_compare(a, lhs, rhs);

  case Tag_SmallInt:
    return number_power__smallint__smallint(a, lhs, rhs);

    return -1;

    return pack_undefined();

static int number_compare(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static uint64_t number_power(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

  case Tag_Integer:
    return integer_compare(a, lhs, rhs);

  case Tag_SmallInt:
    return number_power__smallint(a, lhs, rhs);
  default:
    return pack_undefined();
  }
}
static int number_compare__smallint__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return unpack_smallint(rhs) - unpack_smallint(lhs);
}
static int number_compare__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  assert(is_number(rhs));
  switch(get_tag(rhs)) {
  case Tag_SmallInt:
    return number_compare__smallint__smallint(a, lhs, rhs);

static uint64_t embed_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator) {
  uint64_t values[2] = {numerator, denominator};
  uint32_t index = embed_values(a, 2, values);
  return pack_fraction(index);

static int number_compare(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  assert(is_number(lhs));
  assert(is_number(rhs));
  switch(get_tag(lhs)) {
  case Tag_SmallInt:
    return number_compare__smallint(a, lhs, rhs);
  default:
    return 0;
  }

uint64_t solver_Algebra_integer(struct solver_Algebra *a, int64_t value) {
  return pack_integer(value);
}
uint64_t solver_Algebra_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator) {
  return embed_fraction(a, numerator, denominator);
}

// 010 - integer  - 32-bit integer
// 011 - integer  - pointer to big integer implementation

// 010 - small integer
// 011 - large integer

// 

// new integer encoding
//                             0x0000800000000000 == flag mask
//                                   800000000000 == both  - negative flag
//                                   7FFFFFFFFFFF == small - uint44_t
//                                   7FFFFF000000 == large - 21-bit count
//                                         FFFFFF == large - 24-bit index

#define TAG_INTEGER_BITS       0x7FF2000000000000ull
#define TAG_BIGINT_BITS        0x7FF3000000000000ull

#define TAG_SMALLINT_BITS      0x7FF2000000000000ull
#define TAG_LARGEINT_BITS      0x7FF3000000000000ull

#define TAG_UNUSED1_BITS       0x7FF6000000000000ull
#define TAG_UNUSED2_BITS       0x7FF7000000000000ull

#define TAG_UNUSED6_BITS       0x7FF6000000000000ull
#define TAG_UNUSED7_BITS       0x7FF7000000000000ull

#define PAIR_INDEX_MASK        0x0000000000FFFFFFull
#define LIST_COUNT_MASK        0x00007FFFFF000000ull
#define LIST_INDEX_MASK        0x0000000000FFFFFFull

#define PAIR_INDEX_MASK        0x0000000000FFFFFFull // 24-bits
#define LIST_COUNT_MASK        0x00007FFFFF000000ull // 23-bits
#define LIST_INDEX_MASK        0x0000000000FFFFFFull // 24-bits
#define INTEGER_MASK           0xFFFE000000000000ull // mask ignores small or large integer descriminating bit
#define INTEGER_BITS           0x7FF2000000000000ull
#define INTEGER_NEG_FLAG_BIT   0x0000800000000000ull
#define INTEGER_COUNT_MASK     0x00007FFFFF000000ull // 23-bits
#define INTEGER_INDEX_MASK     0x0000000000FFFFFFull // 24-bits
#define INTEGER_SMALL_MASK     0x00007FFFFFFFFFFFull // 47-bits
#define LITERAL_FALSE          (TAG_ATOM_BITS     | 0)
#define LITERAL_TRUE           (TAG_ATOM_BITS     | 1)
#define LITERAL_UNDEFINED      (TAG_ATOM_BITS     | 2)
#define LITERAL_ZERO           (TAG_SMALLINT_BITS | 0)
#define LITERAL_ONE            (TAG_SMALLINT_BITS | 1)
#define LITERAL_TWO            (TAG_SMALLINT_BITS | 2)
#define LITERAL_NEGATIVE_ONE   (TAG_SMALLINT_BITS | INTEGER_NEG_FLAG_BIT | 1)

static uint64_t get_pair_index(uint64_t expr) {

static uint32_t get_pair_index(uint64_t expr) {

static uint64_t get_list_count(uint64_t expr) {

static uint32_t get_list_count(uint64_t expr) {

static uint64_t get_list_index(uint64_t expr) {

static uint32_t get_list_index(uint64_t expr) {

static uint32_t get_integer_count(uint64_t expr) {
  assert((expr & TAG_MASK) == TAG_LARGEINT_BITS);
  return (expr & INTEGER_COUNT_MASK) >> 24;
}
static uint32_t get_integer_index(uint64_t expr) {
  assert((expr & TAG_MASK) == TAG_LARGEINT_BITS);
  return (expr & INTEGER_INDEX_MASK);
}
struct EncodedList {
  uint32_t count;
  uint32_t index;
};

union Int32x2 {
  int32_t i[2];
  uint64_t u;
};

DEFINE_ENCODING(
  integer, int32_t,
  { return (packed & TAG_MASK) == TAG_INTEGER_BITS; },
  {
    union Int32x2 _;
    _.i[0] = unpacked;
    _.i[1] = unpacked;
    return TAG_INTEGER_BITS | (_.u & PAYLOAD_MASK);
  },
  {
    union Int32x2 _;
    _.u = packed & PAYLOAD_MASK;
    return _.i[0] | _.i[1];

static inline bool is_smallint(uint64_t packed) {
  return (packed & TAG_MASK) == TAG_SMALLINT_BITS;
}
static inline uint64_t pack_smallint(int64_t value) {
  uint64_t result = TAG_SMALLINT_BITS;
  if(value < 0) {
    result |= INTEGER_NEG_FLAG_BIT;
    value *= -1;

)

  assert((value & ~INTEGER_SMALL_MASK) == 0);
  return result | value;
}
static inline int64_t unpack_smallint(uint64_t expr) {
  assert(is_smallint(expr));
  return (((expr & INTEGER_NEG_FLAG_BIT) == INTEGER_NEG_FLAG_BIT) ? -1 : 1) * ((int64_t)(expr & INTEGER_SMALL_MASK));
}

struct BigInteger {
  int64_t big;
};
DEFINE_ENCODING(
  big_integer, struct BigInteger *,
  { return (packed & TAG_MASK) == TAG_BIGINT_BITS; },
  { return TAG_BIGINT_BITS | ((uint64_t)unpacked & PAYLOAD_MASK); },
  { return (struct BigInteger *)(packed & PAYLOAD_MASK); }
)

static inline bool is_largeint(uint64_t packed) {
  return (packed & TAG_MASK) == TAG_LARGEINT_BITS;
}
static inline uint64_t pack_largeint(uint64_t flags, uint32_t count, uint32_t index) {
  return TAG_LARGEINT_BITS | flags | (count << 24) | index;
}
static inline struct EncodedList unpack_largeint(uint64_t packed) {
  struct EncodedList _;
  _.count = (packed & INTEGER_COUNT_MASK) >> 24;
  _.index = (packed & INTEGER_INDEX_MASK);
  return _;
}

struct EncodedList {
  uint32_t count;
  uint32_t index;
};

  Tag_Integer,
  Tag_BigInteger,

  Tag_SmallInt,
  Tag_LargeInt,

  } else if(is_integer(bits)) {
    return Tag_Integer;
  } else if(is_big_integer(bits)) {
    return Tag_BigInteger;

  } else if(is_smallint(bits)) {
    return Tag_SmallInt;

static bool equals__real_real(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__real__real(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__real_real(a, lhs, rhs);

    return equals__real__real(a, lhs, rhs);

static bool equals__variable_variable(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__variable__variable(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__variable_variable(a, lhs, rhs);

    return equals__variable__variable(a, lhs, rhs);

static bool equals__boolean_boolean(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__boolean__boolean(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__boolean_boolean(a, lhs, rhs);

    return equals__boolean__boolean(a, lhs, rhs);

static bool equals__undefined_undefined(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__undefined__undefined(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__undefined_undefined(a, lhs, rhs);

    return equals__undefined__undefined(a, lhs, rhs);

static bool equals__integer_integer(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return unpack_integer(lhs) == unpack_integer(rhs);

static bool equals__smallint__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return unpack_smallint(lhs) == unpack_smallint(rhs);

static bool equals__integer(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__smallint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

  case Tag_Integer:
    return equals__integer_integer(a, lhs, rhs);

  case Tag_SmallInt:
    return equals__smallint__smallint(a, lhs, rhs);

static bool equals__big_integer_big_integer(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }
static bool equals__big_integer(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__largeint__largeint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }
static bool equals__largeint(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

  case Tag_BigInteger:
    return equals__big_integer_big_integer(a, lhs, rhs);

  case Tag_LargeInt:
    return equals__largeint__largeint(a, lhs, rhs);

static bool equals__fraction_fraction(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }

static bool equals__fraction__fraction(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { return false; }

    return equals__fraction_fraction(a, lhs, rhs);

    return equals__fraction__fraction(a, lhs, rhs);

static bool equals__power_power(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__power__power(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__power_power(a, lhs, rhs);

    return equals__power__power(a, lhs, rhs);

static bool equals__sum_sum(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__sum__sum(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__sum_sum(a, lhs, rhs);

    return equals__sum__sum(a, lhs, rhs);

static bool equals__product_product(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__product__product(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__product_product(a, lhs, rhs);

    return equals__product__product(a, lhs, rhs);

static bool equals__equals_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return equals(a, get_car(a, lhs), get_car(a, rhs)) && equals(a, get_cdr(a, lhs), get_cdr(a, rhs));

static bool equals__equals__equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {
  return equals(a, get_car(a, lhs), get_car(a, rhs)) &&
         equals(a, get_cdr(a, lhs), get_cdr(a, rhs));

    return equals__equals_equals(a, lhs, rhs);

    return equals__equals__equals(a, lhs, rhs);

static bool equals__not_equals_not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__not_equals__not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__not_equals_not_equals(a, lhs, rhs);

    return equals__not_equals__not_equals(a, lhs, rhs);

static bool equals__less_than_less_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__less_than__less_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__less_than_less_than(a, lhs, rhs);

    return equals__less_than__less_than(a, lhs, rhs);

static bool equals__greater_than_greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

static bool equals__greater_than__greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {

    return equals__greater_than_greater_than(a, lhs, rhs);

    return equals__greater_than__greater_than(a, lhs, rhs);

  case Tag_Integer:
    return equals__integer(a, lhs, rhs);
  case Tag_BigInteger:
    return equals__big_integer(a, lhs, rhs);

  case Tag_SmallInt:
    return equals__smallint(a, lhs, rhs);
  case Tag_LargeInt:
    return equals__largeint(a, lhs, rhs);

}
static inline uint64_t solver_Algebra_inverse(struct solver_Algebra *a, uint64_t expr) {
  return solver_Algebra_power(a, expr, solver_Algebra_integer(a, -1));

  return solver_Algebra_multiply(a, lhs, solver_Algebra_power(a, rhs, solver_Algebra_integer(a, -1)));

  return solver_Algebra_multiply(a, lhs, solver_Algebra_inverse(a, rhs));