diff --git a/poincare/include/poincare/based_integer.h b/poincare/include/poincare/based_integer.h
index bfee17f28..af4ce52b9 100644
--- a/poincare/include/poincare/based_integer.h
+++ b/poincare/include/poincare/based_integer.h
@@ -52,7 +52,7 @@ public:
   /* The constructor build a irreductible fraction */
   BasedInteger(const BasedIntegerNode * node) : Number(node) {}
   static BasedInteger Builder(const char * digits, size_t size, Integer::Base base);
-  static BasedInteger Builder(const Integer & m, Integer::Base base);
+  static BasedInteger Builder(const Integer & m, Integer::Base base = Integer::Base::Decimal);
 
   // TreeNode
   BasedIntegerNode * node() const { return static_cast<BasedIntegerNode *>(Number::node()); }
diff --git a/poincare/test/approximation.cpp b/poincare/test/approximation.cpp
index d57065930..7d03c09d9 100644
--- a/poincare/test/approximation.cpp
+++ b/poincare/test/approximation.cpp
@@ -35,6 +35,11 @@ QUIZ_CASE(poincare_approximation_decimal) {
   assert_expression_approximates_to_scalar<double>("-567.2ᴇ2", -56720.0);
 }
 
+QUIZ_CASE(poincare_approximation_based_integer) {
+  assert_expression_approximates_to<float>("1232", "1232");
+  assert_expression_approximates_to<double>("0b110101", "53");
+  assert_expression_approximates_to<double>("0xabc1234", "180097588");
+}
 
 QUIZ_CASE(poincare_approximation_rational) {
   assert_expression_approximates_to<float>("1/3", "0.3333333");
diff --git a/poincare/test/expression_properties.cpp b/poincare/test/expression_properties.cpp
index 2296092e3..f93205732 100644
--- a/poincare/test/expression_properties.cpp
+++ b/poincare/test/expression_properties.cpp
@@ -4,6 +4,9 @@
 using namespace Poincare;
 
 QUIZ_CASE(poincare_properties_is_number) {
+  quiz_assert(BasedInteger::Builder("2",Integer::Base::Binary).isNumber());
+  quiz_assert(BasedInteger::Builder("2",Integer::Base::Decimal).isNumber());
+  quiz_assert(BasedInteger::Builder("2",Integer::Base::Hexadecimal).isNumber());
   quiz_assert(Decimal::Builder("2",3).isNumber());
   quiz_assert(Float<float>::Builder(1.0f).isNumber());
   quiz_assert(Infinity::Builder(true).isNumber());
@@ -114,6 +117,12 @@ QUIZ_CASE(poincare_properties_decimal_sign) {
   quiz_assert(Decimal::Builder(0, 1).sign() == ExpressionNode::Sign::Positive);
 }
 
+QUIZ_CASE(poincare_properties_based_integer_sign) {
+  quiz_assert(BasedInteger::Builder(2, Integer::Base::Binary).sign() == ExpressionNode::Sign::Positive);
+  quiz_assert(BasedInteger::Builder(2, Integer::Base::Decimal).sign() == ExpressionNode::Sign::Positive);
+  quiz_assert(BasedInteger::Builder(2, Integer::Base::Hexadecimal).sign() == ExpressionNode::Sign::Positive);
+}
+
 QUIZ_CASE(poincare_properties_rational_sign) {
   quiz_assert(Rational::Builder(-2).sign() == ExpressionNode::Sign::Negative);
   quiz_assert(Rational::Builder(-2, 3).sign() == ExpressionNode::Sign::Negative);
diff --git a/poincare/test/expression_serialization.cpp b/poincare/test/expression_serialization.cpp
index 618af624b..8972460e6 100644
--- a/poincare/test/expression_serialization.cpp
+++ b/poincare/test/expression_serialization.cpp
@@ -9,6 +9,12 @@ void assert_expression_serialize_to(Poincare::Expression expression, const char
   quiz_assert_print_if_failure(strcmp(serialization, buffer) == 0, serialization);
 }
 
+QUIZ_CASE(poincare_serialization_based_integer) {
+  assert_expression_serialize_to(BasedInteger::Builder(Integer(23), Integer::Base::Decimal), "23");
+  assert_expression_serialize_to(BasedInteger::Builder(Integer(23), Integer::Base::Binary), "0b10111");
+  assert_expression_serialize_to(BasedInteger::Builder(Integer(23), Integer::Base::Hexadecimal), "0x17");
+}
+
 QUIZ_CASE(poincare_serialization_rational) {
   assert_expression_serialize_to(Rational::Builder(2,3), "2/3");
   assert_expression_serialize_to(Rational::Builder("12345678910111213","123456789101112131"), "12345678910111213/123456789101112131");
diff --git a/poincare/test/expression_to_layout.cpp b/poincare/test/expression_to_layout.cpp
index 045cb3b0f..8bbd5ae8e 100644
--- a/poincare/test/expression_to_layout.cpp
+++ b/poincare/test/expression_to_layout.cpp
@@ -50,6 +50,14 @@ QUIZ_CASE(poincare_expression_to_layout_multiplication_operator) {
   // BoundaryPunctuation x Root
   assert_expression_layouts_and_serializes_to(Multiplication::Builder(Cosine::Builder(Rational::Builder(2)), SquareRoot::Builder(Rational::Builder(2))), "cos(2)√\u00122\u0013");
 
+  // BasedInteger x OneLetter
+  // 0b101π
+  assert_expression_layouts_and_serializes_to(Multiplication::Builder(BasedInteger::Builder("5", Integer::Base::Binary), Symbol::Builder(UCodePointGreekSmallLetterPi)), "0b101π");
+  // 0x23π
+  assert_expression_layouts_and_serializes_to(Multiplication::Builder(BasedInteger::Builder("35", Integer::Base::Hexadecimal), Symbol::Builder(UCodePointGreekSmallLetterPi)), "0x23π");
+  // 0x2Aπ
+  assert_expression_layouts_and_serializes_to(Multiplication::Builder(BasedInteger::Builder("42", Integer::Base::Hexadecimal), Symbol::Builder(UCodePointGreekSmallLetterPi)), "0x2A·π");
+
   // 2√(2)
   assert_expression_layouts_and_serializes_to(Multiplication::Builder(Rational::Builder(2), SquareRoot::Builder(Rational::Builder(2))), "2√\u00122\u0013");
   // √(2)x2
diff --git a/poincare/test/integer.cpp b/poincare/test/integer.cpp
index d58da4a47..0a093c132 100644
--- a/poincare/test/integer.cpp
+++ b/poincare/test/integer.cpp
@@ -16,6 +16,9 @@ QUIZ_CASE(poincare_integer_constructor) {
   Integer d((int64_t)1234567891011121314);
   Integer nd((int64_t)(-1234567891011121314));
   Integer e = Integer::Overflow(false);
+  Integer f("101011", 6, false, Integer::Base::Binary);
+  Integer g("A2B3", 4, false, Integer::Base::Hexadecimal);
+  Integer h("123", 3, false, Integer::Base::Decimal);
 }
 
 static inline void assert_equal(const Integer i, const Integer j) {
@@ -206,8 +209,8 @@ QUIZ_CASE(poincare_integer_factorial) {
 // Simplify
 
 template<typename T>
-void assert_integer_evals_to(const char * i, T result) {
-  quiz_assert(Integer(i).approximate<T>() == result);
+void assert_integer_evals_to(const char * i, T result, Integer::Base base = Integer::Base::Decimal) {
+  quiz_assert(Integer(i, strlen(i), false, base).approximate<T>() == result);
 }
 
 QUIZ_CASE(poincare_integer_evaluate) {
@@ -248,13 +251,18 @@ QUIZ_CASE(poincare_integer_evaluate) {
   assert_integer_evals_to("179769313486230000002930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137215", 1.7976931348622999E+308);
   assert_integer_evals_to(OverflowedIntegerString(), 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216.0);
   assert_integer_evals_to(MaxIntegerString(), 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137215.0);
+
+  // Based Integer
+  assert_integer_evals_to("1011", 11.0f, Integer::Base::Binary);
+  assert_integer_evals_to("2A", 42.0f, Integer::Base::Hexadecimal);
+  assert_integer_evals_to("42", 42.0f, Integer::Base::Decimal);
 }
 
 //Serialize
 
-static inline void assert_integer_serializes_to(const Integer i, const char * serialization) {
+static inline void assert_integer_serializes_to(const Integer i, const char * serialization, Integer::Base base = Integer::Base::Decimal) {
   char buffer[500];
-  i.serialize(buffer, 500);
+  i.serialize(buffer, 500, base);
   quiz_assert(strcmp(buffer, serialization) == 0);
 }
 
@@ -262,6 +270,10 @@ QUIZ_CASE(poincare_integer_serialize) {
   assert_integer_serializes_to(Integer(-2), "-2");
   assert_integer_serializes_to(Integer("2345678909876"), "2345678909876");
   assert_integer_serializes_to(Integer("-2345678909876"), "-2345678909876");
+  assert_integer_serializes_to(Integer(9), "0b1001", Integer::Base::Binary);
+  assert_integer_serializes_to(Integer(9131), "0x23AB", Integer::Base::Hexadecimal);
+  assert_integer_serializes_to(Integer(123), "123", Integer::Base::Decimal);
+  assert_integer_serializes_to(Integer("-2345678909876"), "-2345678909876");
   assert_integer_serializes_to(MaxInteger(), MaxIntegerString());
   assert_integer_serializes_to(OverflowedInteger(), Infinity::Name());
 }
diff --git a/poincare/test/layout_to_expression.cpp b/poincare/test/layout_to_expression.cpp
index f991c0b8a..327f65619 100644
--- a/poincare/test/layout_to_expression.cpp
+++ b/poincare/test/layout_to_expression.cpp
@@ -281,7 +281,7 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
       CodePointLayout::Builder('1'),
       CodePointLayout::Builder('+'),
       CodePointLayout::Builder('2'));
-  e = Addition::Builder(Rational::Builder(1), Rational::Builder(2));
+  e = Addition::Builder(BasedInteger::Builder(1), BasedInteger::Builder(2));
   assert_parsed_layout_is(l, e);
 
   // |3+3/6|
@@ -294,10 +294,10 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
           CodePointLayout::Builder('6'))));
   e = AbsoluteValue::Builder(
       Addition::Builder(
-        Rational::Builder(3),
+        BasedInteger::Builder(3),
         Division::Builder(
-          Rational::Builder(3),
-          Rational::Builder(6))));
+          BasedInteger::Builder(3),
+          BasedInteger::Builder(6))));
   assert_parsed_layout_is(l, e);
 
   // binCoef(4,5)
@@ -305,8 +305,8 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
       CodePointLayout::Builder('4'),
       CodePointLayout::Builder('5'));
   e = BinomialCoefficient::Builder(
-      Rational::Builder(4),
-      Rational::Builder(5));
+      BasedInteger::Builder(4),
+      BasedInteger::Builder(5));
   assert_parsed_layout_is(l, e);
 
   // ceil(4.6)
@@ -339,10 +339,10 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
           CodePointLayout::Builder('4')),
         VerticalOffsetLayoutNode::Position::Superscript));
   e = Power::Builder(
-      Rational::Builder(2),
+      BasedInteger::Builder(2),
       Addition::Builder(
-        Rational::Builder(3),
-        Rational::Builder(4)));
+        BasedInteger::Builder(3),
+        BasedInteger::Builder(4)));
   assert_parsed_layout_is(l, e);
 
   // 2^(3+4)!
@@ -357,10 +357,10 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
       CodePointLayout::Builder('!'));
   e = Factorial::Builder(
       Power::Builder(
-        Rational::Builder(2),
+        BasedInteger::Builder(2),
         Addition::Builder(
-          Rational::Builder(3),
-          Rational::Builder(4))));
+          BasedInteger::Builder(3),
+          BasedInteger::Builder(4))));
   assert_parsed_layout_is(l, e);
 
 
@@ -375,15 +375,15 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
   l1.addChildAtIndex(RightParenthesisLayout::Builder(), l1.numberOfChildren(),  l1.numberOfChildren(), nullptr);
   l = l1;
   e = Logarithm::Builder(
-      Rational::Builder(2),
-      Rational::Builder(3));
+      BasedInteger::Builder(2),
+      BasedInteger::Builder(3));
   assert_parsed_layout_is(l, e);
 
   // root(5,3)
   l = NthRootLayout::Builder(
       CodePointLayout::Builder('5'),
       CodePointLayout::Builder('3'));
-  e = NthRoot::Builder(Rational::Builder(5), Rational::Builder(3));
+  e = NthRoot::Builder(BasedInteger::Builder(5), BasedInteger::Builder(3));
   assert_parsed_layout_is(l, e);
 
   // int(7, x, 4, 5)
@@ -393,10 +393,10 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
       CodePointLayout::Builder('4'),
       CodePointLayout::Builder('5'));
   e = Integral::Builder(
-      Rational::Builder(7),
+      BasedInteger::Builder(7),
       Symbol::Builder('x'),
-      Rational::Builder(4),
-      Rational::Builder(5));
+      BasedInteger::Builder(4),
+      BasedInteger::Builder(5));
   assert_parsed_layout_is(l, e);
 
   // 2^2 !
@@ -408,8 +408,8 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
       CodePointLayout::Builder('!'));
   e = Factorial::Builder(
       Power::Builder(
-        Rational::Builder(2),
-        Rational::Builder(2)));
+        BasedInteger::Builder(2),
+        BasedInteger::Builder(2)));
   assert_parsed_layout_is(l, e);
 
   // 5* 6/(7+5) *3
@@ -423,14 +423,14 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
           CodePointLayout::Builder('5'))),
       CodePointLayout::Builder('3'));
   e = Multiplication::Builder(
-      Rational::Builder(5),
+      BasedInteger::Builder(5),
       Multiplication::Builder(
         Division::Builder(
-          Rational::Builder(6),
+          BasedInteger::Builder(6),
           Addition::Builder(
-            Rational::Builder(7),
-            Rational::Builder(5))),
-        Rational::Builder(3)));
+            BasedInteger::Builder(7),
+            BasedInteger::Builder(5))),
+        BasedInteger::Builder(3)));
   assert_parsed_layout_is(l, e);
 
   // [[3^2!, 7][4,5]
@@ -447,11 +447,11 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
   Matrix m = BuildOneChildMatrix(
       Factorial::Builder(
         Power::Builder(
-          Rational::Builder(3),
-          Rational::Builder(2))));
-  m.addChildAtIndexInPlace(Rational::Builder(7), 1, 1);
-  m.addChildAtIndexInPlace(Rational::Builder(4), 2, 2);
-  m.addChildAtIndexInPlace(Rational::Builder(5), 3, 3);
+          BasedInteger::Builder(3),
+          BasedInteger::Builder(2))));
+  m.addChildAtIndexInPlace(BasedInteger::Builder(7), 1, 1);
+  m.addChildAtIndexInPlace(BasedInteger::Builder(4), 2, 2);
+  m.addChildAtIndexInPlace(BasedInteger::Builder(5), 3, 3);
   m.setDimensions(2,2);
   e = m;
   assert_parsed_layout_is(l, e);
@@ -470,12 +470,12 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
         VerticalOffsetLayoutNode::Position::Superscript));
   m = BuildOneChildMatrix(
       Factorial::Builder(
-        Rational::Builder(3)));
-  m.addChildAtIndexInPlace(Rational::Builder(7), 1, 1);
-  m.addChildAtIndexInPlace(Rational::Builder(4), 2, 2);
-  m.addChildAtIndexInPlace(Rational::Builder(5), 3, 3);
+        BasedInteger::Builder(3)));
+  m.addChildAtIndexInPlace(BasedInteger::Builder(7), 1, 1);
+  m.addChildAtIndexInPlace(BasedInteger::Builder(4), 2, 2);
+  m.addChildAtIndexInPlace(BasedInteger::Builder(5), 3, 3);
   m.setDimensions(2,2);
-  e = Power::Builder(Rational::Builder(2), m);
+  e = Power::Builder(BasedInteger::Builder(2), m);
   assert_parsed_layout_is(l, e);
 
   // 2e^3
@@ -485,7 +485,7 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
       VerticalOffsetLayout::Builder(
         CodePointLayout::Builder('3'),
         VerticalOffsetLayoutNode::Position::Superscript));
-  e = Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE), Rational::Builder(3)));
+  e = Multiplication::Builder(BasedInteger::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE), BasedInteger::Builder(3)));
   assert_parsed_layout_is(l, e);
 
   // x|2|
@@ -495,7 +495,7 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
         CodePointLayout::Builder('2')));
   e = Multiplication::Builder(
       Symbol::Builder('x'),
-      AbsoluteValue::Builder(Rational::Builder(2)));
+      AbsoluteValue::Builder(BasedInteger::Builder(2)));
   assert_parsed_layout_is(l, e);
 
   // x int(7, x, 4, 5)
@@ -509,9 +509,9 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
   e = Multiplication::Builder(
       Symbol::Builder('x'),
       Integral::Builder(
-        Rational::Builder(7),
+        BasedInteger::Builder(7),
         Symbol::Builder('x'),
-        Rational::Builder(4),
-        Rational::Builder(5)));
+        BasedInteger::Builder(4),
+        BasedInteger::Builder(5)));
   assert_parsed_layout_is(l, e);
 }
diff --git a/poincare/test/parsing.cpp b/poincare/test/parsing.cpp
index dc11804ef..cf707ea11 100644
--- a/poincare/test/parsing.cpp
+++ b/poincare/test/parsing.cpp
@@ -62,6 +62,11 @@ QUIZ_CASE(poincare_parsing_tokenize_numbers) {
   assert_tokenizes_as_number("1.ᴇ-4");
   assert_tokenizes_as_number("1.ᴇ9999");
 
+  const Token::Type binaryType[] = {Token::BinaryNumber, Token::EndOfStream};
+  assert_tokenizes_as(binaryType, "0b0011010101");
+  const Token::Type hexadecimalType[] = {Token::HexadecimalNumber, Token::EndOfStream};
+  assert_tokenizes_as(hexadecimalType, "0x1234567890ABCDEF");
+
   assert_tokenizes_as_undefined_token("1ᴇ");
   assert_tokenizes_as_undefined_token("1..");
   assert_tokenizes_as_undefined_token("..");
@@ -70,11 +75,13 @@ QUIZ_CASE(poincare_parsing_tokenize_numbers) {
   assert_tokenizes_as_undefined_token("1ᴇ--4");
   assert_tokenizes_as_undefined_token("1.ᴇᴇ4");
   assert_tokenizes_as_undefined_token("1ᴇ2ᴇ4");
+  assert_tokenizes_as_undefined_token("0b2");
+  assert_tokenizes_as_undefined_token("0xG");
 }
 
 QUIZ_CASE(poincare_parsing_memory_exhaustion) {
   int initialPoolSize = pool_size();
-  assert_parsed_expression_is("2+3",Addition::Builder(Rational::Builder(2), Rational::Builder(3)));
+  assert_parsed_expression_is("2+3",Addition::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3)));
   assert_pool_size(initialPoolSize);
 
   int memoryFailureHasBeenHandled = false;
@@ -101,9 +108,9 @@ QUIZ_CASE(poincare_parsing_memory_exhaustion) {
 
 QUIZ_CASE(poincare_parsing_parse_numbers) {
   // Parse decimal
-  assert_parsed_expression_is("0", Rational::Builder(0));
+  assert_parsed_expression_is("0", BasedInteger::Builder(0));
   assert_parsed_expression_is("0.1", Decimal::Builder(0.1));
-  assert_parsed_expression_is("1.", Rational::Builder(1));
+  assert_parsed_expression_is("1.", BasedInteger::Builder(1));
   assert_parsed_expression_is(".1", Decimal::Builder(0.1));
   assert_parsed_expression_is("0ᴇ2", Decimal::Builder(0.0));
   assert_parsed_expression_is("0.1ᴇ2", Decimal::Builder(10.0));
@@ -129,8 +136,12 @@ QUIZ_CASE(poincare_parsing_parse_numbers) {
   assert_parsed_expression_is("99299.9999999999", Decimal::Builder(Integer("99300000000000"), 4));
 
   // Parse integer
-  assert_parsed_expression_is("123456789012345678765434567", Rational::Builder("123456789012345678765434567"));
-  assert_parsed_expression_is(MaxIntegerString(), Rational::Builder(MaxIntegerString()));
+  assert_parsed_expression_is("123456789012345678765434567", BasedInteger::Builder("123456789012345678765434567"));
+  assert_parsed_expression_is(MaxIntegerString(), BasedInteger::Builder(MaxIntegerString()));
+
+  // Parsed Based integer
+  assert_parsed_expression_is("0b1011", BasedInteger::Builder("1011", 4, Integer::Base::Binary));
+  assert_parsed_expression_is("0x12AC", BasedInteger::Builder("12AC", 4, Integer::Base::Hexadecimal));
 
   // Integer parsed in Decimal because they overflow Integer
   assert_parsed_expression_is(OverflowedIntegerString(), Decimal::Builder(Integer("17976931348623"), 308));
@@ -146,70 +157,70 @@ QUIZ_CASE(poincare_parsing_parse_numbers) {
 }
 
 QUIZ_CASE(poincare_parsing_parse) {
-  assert_parsed_expression_is("1", Rational::Builder(1));
-  assert_parsed_expression_is("(1)", Parenthesis::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("((1))", Parenthesis::Builder((Expression)Parenthesis::Builder(Rational::Builder(1))));
-  assert_parsed_expression_is("1+2", Addition::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("(1)+2", Addition::Builder(Parenthesis::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("(1+2)", Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2))));
-  Expression nAryChildren[] = {Rational::Builder(1),Rational::Builder(2),Rational::Builder(3)};
+  assert_parsed_expression_is("1", BasedInteger::Builder(1));
+  assert_parsed_expression_is("(1)", Parenthesis::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("((1))", Parenthesis::Builder((Expression)Parenthesis::Builder(BasedInteger::Builder(1))));
+  assert_parsed_expression_is("1+2", Addition::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("(1)+2", Addition::Builder(Parenthesis::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("(1+2)", Parenthesis::Builder(Addition::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))));
+  Expression nAryChildren[] = {BasedInteger::Builder(1),BasedInteger::Builder(2),BasedInteger::Builder(3)};
   assert_parsed_expression_is("1+2+3", Addition::Builder(nAryChildren, 3));
-  nAryChildren[2] = Parenthesis::Builder(Addition::Builder(Rational::Builder(3),Rational::Builder(4)));
+  nAryChildren[2] = Parenthesis::Builder(Addition::Builder(BasedInteger::Builder(3),BasedInteger::Builder(4)));
   assert_parsed_expression_is("1+2+(3+4)", Addition::Builder(nAryChildren, 3));
-  assert_parsed_expression_is("1×2", Multiplication::Builder(Rational::Builder(1),Rational::Builder(2)));
-  nAryChildren[2] = Rational::Builder(3);
+  assert_parsed_expression_is("1×2", Multiplication::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  nAryChildren[2] = BasedInteger::Builder(3);
   assert_parsed_expression_is("1×2×3", Multiplication::Builder(nAryChildren, 3));
-  assert_parsed_expression_is("1+2×3", Addition::Builder(Rational::Builder(1), Multiplication::Builder(Rational::Builder(2), Rational::Builder(3))));
-  assert_parsed_expression_is("1/2", Division::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("(1/2)", Parenthesis::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2))));
-  assert_parsed_expression_is("1/2/3", Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("1/2×3", Multiplication::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(Multiplication::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))));
-  assert_parsed_expression_is("1×2/3", Multiplication::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))));
-  assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(Multiplication::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))));
-  assert_parsed_expression_is("(1/2/3)", Parenthesis::Builder(Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))));
-  assert_parsed_expression_is("1^2", Power::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("1^2^3", Power::Builder(Rational::Builder(1),Power::Builder(Rational::Builder(2),Rational::Builder(3))));
-  assert_parsed_expression_is("1=2", Equal::Builder(Rational::Builder(1),Rational::Builder(2)));
+  assert_parsed_expression_is("1+2×3", Addition::Builder(BasedInteger::Builder(1), Multiplication::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3))));
+  assert_parsed_expression_is("1/2", Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("(1/2)", Parenthesis::Builder(Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1/2/3", Division::Builder(Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("1/2×3", Multiplication::Builder(Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(Multiplication::Builder(Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),BasedInteger::Builder(3))));
+  assert_parsed_expression_is("1×2/3", Multiplication::Builder(BasedInteger::Builder(1),Division::Builder(BasedInteger::Builder(2),BasedInteger::Builder(3))));
+  assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(Multiplication::Builder(BasedInteger::Builder(1),Division::Builder(BasedInteger::Builder(2),BasedInteger::Builder(3)))));
+  assert_parsed_expression_is("(1/2/3)", Parenthesis::Builder(Division::Builder(Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),BasedInteger::Builder(3))));
+  assert_parsed_expression_is("1^2", Power::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1^2^3", Power::Builder(BasedInteger::Builder(1),Power::Builder(BasedInteger::Builder(2),BasedInteger::Builder(3))));
+  assert_parsed_expression_is("1=2", Equal::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_text_not_parsable("=5");
   assert_text_not_parsable("1=2=3");
-  assert_parsed_expression_is("-1", Opposite::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("(-1)", Parenthesis::Builder(Opposite::Builder(Rational::Builder(1))));
-  assert_parsed_expression_is("1-2", Subtraction::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("-1-2", Subtraction::Builder(Opposite::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1-2-3", Subtraction::Builder(Subtraction::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("(1-2)", Parenthesis::Builder(Subtraction::Builder(Rational::Builder(1),Rational::Builder(2))));
-  assert_parsed_expression_is("1+-2", Addition::Builder(Rational::Builder(1),Opposite::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("--1", Opposite::Builder((Expression)Opposite::Builder(Rational::Builder(1))));
-  assert_parsed_expression_is("(1+2)-3", Subtraction::Builder(Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2))),Rational::Builder(3)));
-  assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(Multiplication::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3)))));
-  assert_parsed_expression_is("1^(2)-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))),Rational::Builder(3)));
-  assert_parsed_expression_is("1^2-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("2^-3", Power::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))));
-  assert_parsed_expression_is("2--2+-1", Addition::Builder(Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(2))),Opposite::Builder(Rational::Builder(1))));
-  assert_parsed_expression_is("2--2×-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Multiplication::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1))))));
-  assert_parsed_expression_is("-1^2", Opposite::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2))));
-  assert_parsed_expression_is("2ℯ^(3)", Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))));
-  assert_parsed_expression_is("2/-3/-4", Division::Builder(Division::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))),Opposite::Builder(Rational::Builder(4))));
-  assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(Multiplication::Builder(Rational::Builder(1),Rational::Builder(2)),Multiplication::Builder(Rational::Builder(3),Rational::Builder(4))));
-  assert_parsed_expression_is("-1×2", Opposite::Builder(Multiplication::Builder(Rational::Builder(1), Rational::Builder(2))));
-  assert_parsed_expression_is("1!", Factorial::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("1+2!", Addition::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!+2", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1!+2!", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1×2!", Multiplication::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!×2", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1!×2!", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1-2!", Subtraction::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!-2", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1!-2!", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1/2!", Division::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!/2", Division::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1!/2!", Division::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1^2!", Power::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!^2", Power::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1!^2!", Power::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("(1)!", Factorial::Builder(Parenthesis::Builder(Rational::Builder(1))));
+  assert_parsed_expression_is("-1", Opposite::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("(-1)", Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(1))));
+  assert_parsed_expression_is("1-2", Subtraction::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("-1-2", Subtraction::Builder(Opposite::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1-2-3", Subtraction::Builder(Subtraction::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("(1-2)", Parenthesis::Builder(Subtraction::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1+-2", Addition::Builder(BasedInteger::Builder(1),Opposite::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("--1", Opposite::Builder((Expression)Opposite::Builder(BasedInteger::Builder(1))));
+  assert_parsed_expression_is("(1+2)-3", Subtraction::Builder(Parenthesis::Builder(Addition::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(Multiplication::Builder(BasedInteger::Builder(2),Opposite::Builder(BasedInteger::Builder(3)))));
+  assert_parsed_expression_is("1^(2)-3", Subtraction::Builder(Power::Builder(BasedInteger::Builder(1),Parenthesis::Builder(BasedInteger::Builder(2))),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("1^2-3", Subtraction::Builder(Power::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("2^-3", Power::Builder(BasedInteger::Builder(2),Opposite::Builder(BasedInteger::Builder(3))));
+  assert_parsed_expression_is("2--2+-1", Addition::Builder(Subtraction::Builder(BasedInteger::Builder(2),Opposite::Builder(BasedInteger::Builder(2))),Opposite::Builder(BasedInteger::Builder(1))));
+  assert_parsed_expression_is("2--2×-1", Subtraction::Builder(BasedInteger::Builder(2),Opposite::Builder(Multiplication::Builder(BasedInteger::Builder(2),Opposite::Builder(BasedInteger::Builder(1))))));
+  assert_parsed_expression_is("-1^2", Opposite::Builder(Power::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))));
+  assert_parsed_expression_is("2ℯ^(3)", Multiplication::Builder(BasedInteger::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(BasedInteger::Builder(3)))));
+  assert_parsed_expression_is("2/-3/-4", Division::Builder(Division::Builder(BasedInteger::Builder(2),Opposite::Builder(BasedInteger::Builder(3))),Opposite::Builder(BasedInteger::Builder(4))));
+  assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(Multiplication::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)),Multiplication::Builder(BasedInteger::Builder(3),BasedInteger::Builder(4))));
+  assert_parsed_expression_is("-1×2", Opposite::Builder(Multiplication::Builder(BasedInteger::Builder(1), BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!", Factorial::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("1+2!", Addition::Builder(BasedInteger::Builder(1),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!+2", Addition::Builder(Factorial::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1!+2!", Addition::Builder(Factorial::Builder(BasedInteger::Builder(1)),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1×2!", Multiplication::Builder(BasedInteger::Builder(1),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!×2", Multiplication::Builder(Factorial::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1!×2!", Multiplication::Builder(Factorial::Builder(BasedInteger::Builder(1)),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1-2!", Subtraction::Builder(BasedInteger::Builder(1),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!-2", Subtraction::Builder(Factorial::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1!-2!", Subtraction::Builder(Factorial::Builder(BasedInteger::Builder(1)),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1/2!", Division::Builder(BasedInteger::Builder(1),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!/2", Division::Builder(Factorial::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1!/2!", Division::Builder(Factorial::Builder(BasedInteger::Builder(1)),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1^2!", Power::Builder(BasedInteger::Builder(1),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!^2", Power::Builder(Factorial::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1!^2!", Power::Builder(Factorial::Builder(BasedInteger::Builder(1)),Factorial::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("(1)!", Factorial::Builder(Parenthesis::Builder(BasedInteger::Builder(1))));
   assert_text_not_parsable("1+");
   assert_text_not_parsable(")");
   assert_text_not_parsable(")(");
@@ -226,6 +237,8 @@ QUIZ_CASE(poincare_parsing_parse) {
   assert_text_not_parsable("0→x=0");
   assert_text_not_parsable("0=0→x");
   assert_text_not_parsable("1ᴇ2ᴇ3");
+  assert_text_not_parsable("0b001112");
+  //assert_text_not_parsable("0x123G");
 }
 
 Matrix BuildMatrix(int rows, int columns, Expression entries[]) {
@@ -242,13 +255,13 @@ Matrix BuildMatrix(int rows, int columns, Expression entries[]) {
 }
 
 QUIZ_CASE(poincare_parsing_matrices) {
-  Expression m1[] = {Rational::Builder(1)};
+  Expression m1[] = {BasedInteger::Builder(1)};
   assert_parsed_expression_is("[[1]]", BuildMatrix(1,1,m1));
-  Expression m2[] = {Rational::Builder(1),Rational::Builder(2),Rational::Builder(3)};
+  Expression m2[] = {BasedInteger::Builder(1),BasedInteger::Builder(2),BasedInteger::Builder(3)};
   assert_parsed_expression_is("[[1,2,3]]", BuildMatrix(1,3,m2));
-  Expression m3[] = {Rational::Builder(1),Rational::Builder(2),Rational::Builder(3),Rational::Builder(4),Rational::Builder(5),Rational::Builder(6)};
+  Expression m3[] = {BasedInteger::Builder(1),BasedInteger::Builder(2),BasedInteger::Builder(3),BasedInteger::Builder(4),BasedInteger::Builder(5),BasedInteger::Builder(6)};
   assert_parsed_expression_is("[[1,2,3][4,5,6]]", BuildMatrix(2,3,m3));
-  Expression m4[] = {Rational::Builder(1), BuildMatrix(1,1,m1)};
+  Expression m4[] = {BasedInteger::Builder(1), BuildMatrix(1,1,m1)};
   assert_parsed_expression_is("[[1,[[1]]]]", BuildMatrix(1,2,m4));
   assert_text_not_parsable("[");
   assert_text_not_parsable("]");
@@ -281,12 +294,12 @@ QUIZ_CASE(poincare_parsing_symbols_and_functions) {
 
   // User-defined functions
   assert_parsed_expression_is("f(x)", Function::Builder("f", 1, Symbol::Builder("x",1)));
-  assert_parsed_expression_is("f(1)", Function::Builder("f", 1, Rational::Builder(1)));
+  assert_parsed_expression_is("f(1)", Function::Builder("f", 1, BasedInteger::Builder(1)));
   assert_parsed_expression_is("ab12AB_(x)", Function::Builder("ab12AB_", 7, Symbol::Builder("x",1)));
-  assert_parsed_expression_is("ab12AB_(1)", Function::Builder("ab12AB_", 7, Rational::Builder(1)));
+  assert_parsed_expression_is("ab12AB_(1)", Function::Builder("ab12AB_", 7, BasedInteger::Builder(1)));
   assert_parsed_expression_is("f(g(x))", Function::Builder("f", 1, Function::Builder("g", 1, Symbol::Builder("x",1))));
-  assert_parsed_expression_is("f(g(1))", Function::Builder("f", 1, Function::Builder("g", 1, Rational::Builder(1))));
-  assert_parsed_expression_is("f((1))", Function::Builder("f", 1, Parenthesis::Builder(Rational::Builder(1))));
+  assert_parsed_expression_is("f(g(1))", Function::Builder("f", 1, Function::Builder("g", 1, BasedInteger::Builder(1))));
+  assert_parsed_expression_is("f((1))", Function::Builder("f", 1, Parenthesis::Builder(BasedInteger::Builder(1))));
   assert_text_not_parsable("f(1,2)");
   assert_text_not_parsable("f(f)");
   assert_text_not_parsable("abcdefgh(1)");
@@ -303,67 +316,67 @@ QUIZ_CASE(poincare_parsing_symbols_and_functions) {
   assert_text_not_parsable("v");
 
   // Reserved functions
-  assert_parsed_expression_is("acos(1)", ArcCosine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("acosh(1)", HyperbolicArcCosine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("abs(1)", AbsoluteValue::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("arg(1)", ComplexArgument::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("asin(1)", ArcSine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("asinh(1)", HyperbolicArcSine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("atan(1)", ArcTangent::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("atanh(1)", HyperbolicArcTangent::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("binomial(2,1)", BinomialCoefficient::Builder(Rational::Builder(2),Rational::Builder(1)));
-  assert_parsed_expression_is("ceil(1)", Ceiling::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("confidence(1,2)", ConfidenceInterval::Builder(Rational::Builder(1),Rational::Builder(2)));
+  assert_parsed_expression_is("acos(1)", ArcCosine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("acosh(1)", HyperbolicArcCosine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("abs(1)", AbsoluteValue::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("arg(1)", ComplexArgument::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("asin(1)", ArcSine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("asinh(1)", HyperbolicArcSine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("atan(1)", ArcTangent::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("atanh(1)", HyperbolicArcTangent::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("binomial(2,1)", BinomialCoefficient::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)));
+  assert_parsed_expression_is("ceil(1)", Ceiling::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("confidence(1,2)", ConfidenceInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_text_not_parsable("diff(1,2,3)");
-  assert_parsed_expression_is("diff(1,x,3)", Derivative::Builder(Rational::Builder(1),Symbol::Builder("x",1),Rational::Builder(3)));
-  assert_parsed_expression_is("dim(1)", MatrixDimension::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("conj(1)", Conjugate::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("det(1)", Determinant::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("cos(1)", Cosine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("cosh(1)", HyperbolicCosine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("factor(1)", Factor::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("floor(1)", Floor::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("frac(1)", FracPart::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("gcd(1,2)", GreatCommonDivisor::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("im(1)", ImaginaryPart::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("int(1,x,2,3)", Integral::Builder(Rational::Builder(1),Symbol::Builder("x",1),Rational::Builder(2),Rational::Builder(3)));
+  assert_parsed_expression_is("diff(1,x,3)", Derivative::Builder(BasedInteger::Builder(1),Symbol::Builder("x",1),BasedInteger::Builder(3)));
+  assert_parsed_expression_is("dim(1)", MatrixDimension::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("conj(1)", Conjugate::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("det(1)", Determinant::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("cos(1)", Cosine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("cosh(1)", HyperbolicCosine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("factor(1)", Factor::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("floor(1)", Floor::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("frac(1)", FracPart::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("gcd(1,2)", GreatCommonDivisor::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("im(1)", ImaginaryPart::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("int(1,x,2,3)", Integral::Builder(BasedInteger::Builder(1),Symbol::Builder("x",1),BasedInteger::Builder(2),BasedInteger::Builder(3)));
   assert_text_not_parsable("int(1,2,3,4)");
-  assert_parsed_expression_is("inverse(1)", MatrixInverse::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("lcm(1,2)", LeastCommonMultiple::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("ln(1)", NaperianLogarithm::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("log(1)", CommonLogarithm::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("log(1,2)", Logarithm::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("log_{2}(1)", Logarithm::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("permute(2,1)", PermuteCoefficient::Builder(Rational::Builder(2),Rational::Builder(1)));
-  assert_parsed_expression_is("prediction95(1,2)", PredictionInterval::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("prediction(1,2)", SimplePredictionInterval::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("product(1,n,2,3)", Product::Builder(Rational::Builder(1),Symbol::Builder("n",1),Rational::Builder(2),Rational::Builder(3)));
+  assert_parsed_expression_is("inverse(1)", MatrixInverse::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("lcm(1,2)", LeastCommonMultiple::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("ln(1)", NaperianLogarithm::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("log(1)", CommonLogarithm::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("log(1,2)", Logarithm::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("log_{2}(1)", Logarithm::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("permute(2,1)", PermuteCoefficient::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)));
+  assert_parsed_expression_is("prediction95(1,2)", PredictionInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("prediction(1,2)", SimplePredictionInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("product(1,n,2,3)", Product::Builder(BasedInteger::Builder(1),Symbol::Builder("n",1),BasedInteger::Builder(2),BasedInteger::Builder(3)));
   assert_text_not_parsable("product(1,2,3,4)");
-  assert_parsed_expression_is("quo(1,2)", DivisionQuotient::Builder(Rational::Builder(1),Rational::Builder(2)));
+  assert_parsed_expression_is("quo(1,2)", DivisionQuotient::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_parsed_expression_is("random()", Random::Builder());
-  assert_parsed_expression_is("randint(1,2)", Randint::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("re(1)", RealPart::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("rem(1,2)", DivisionRemainder::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("root(1,2)", NthRoot::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("round(1,2)", Round::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("sin(1)", Sine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("sign(1)", SignFunction::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("sinh(1)", HyperbolicSine::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("sum(1,n,2,3)", Sum::Builder(Rational::Builder(1),Symbol::Builder("n",1),Rational::Builder(2),Rational::Builder(3)));
+  assert_parsed_expression_is("randint(1,2)", Randint::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("re(1)", RealPart::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("rem(1,2)", DivisionRemainder::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("root(1,2)", NthRoot::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("round(1,2)", Round::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("sin(1)", Sine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("sign(1)", SignFunction::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("sinh(1)", HyperbolicSine::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("sum(1,n,2,3)", Sum::Builder(BasedInteger::Builder(1),Symbol::Builder("n",1),BasedInteger::Builder(2),BasedInteger::Builder(3)));
   assert_text_not_parsable("sum(1,2,3,4)");
-  assert_parsed_expression_is("tan(1)", Tangent::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("tanh(1)", HyperbolicTangent::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("trace(1)", MatrixTrace::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("transpose(1)", MatrixTranspose::Builder(Rational::Builder(1)));
-  assert_parsed_expression_is("√(1)", SquareRoot::Builder(Rational::Builder(1)));
+  assert_parsed_expression_is("tan(1)", Tangent::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("tanh(1)", HyperbolicTangent::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("trace(1)", MatrixTrace::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("transpose(1)", MatrixTranspose::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("√(1)", SquareRoot::Builder(BasedInteger::Builder(1)));
   assert_text_not_parsable("cos(1,2)");
   assert_text_not_parsable("log(1,2,3)");
 }
 
 QUIZ_CASE(poincare_parsing_parse_store) {
-  assert_parsed_expression_is("1→a", Store::Builder(Rational::Builder(1),Symbol::Builder("a",1)));
-  assert_parsed_expression_is("1→e", Store::Builder(Rational::Builder(1),Symbol::Builder("e",1)));
-  assert_parsed_expression_is("1→f(x)", Store::Builder(Rational::Builder(1),Function::Builder("f",1,Symbol::Builder("x",1))));
+  assert_parsed_expression_is("1→a", Store::Builder(BasedInteger::Builder(1),Symbol::Builder("a",1)));
+  assert_parsed_expression_is("1→e", Store::Builder(BasedInteger::Builder(1),Symbol::Builder("e",1)));
+  assert_parsed_expression_is("1→f(x)", Store::Builder(BasedInteger::Builder(1),Function::Builder("f",1,Symbol::Builder("x",1))));
   assert_parsed_expression_is("x→f(x)", Store::Builder(Symbol::Builder("x",1),Function::Builder("f",1,Symbol::Builder("x",1))));
   assert_parsed_expression_is("n→f(x)", Store::Builder(Symbol::Builder("n",1),Function::Builder("f",1,Symbol::Builder("x",1))));
   Expression m0[] = {Symbol::Builder('x')};
@@ -399,50 +412,50 @@ QUIZ_CASE(poincare_parsing_parse_store) {
 QUIZ_CASE(poincare_parsing_implicit_multiplication) {
   assert_text_not_parsable(".1.2");
   assert_text_not_parsable("1 2");
-  assert_parsed_expression_is("1x", Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)));
-  assert_parsed_expression_is("1ans", Multiplication::Builder(Rational::Builder(1),Symbol::Builder("ans", 3)));
+  assert_parsed_expression_is("1x", Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1)));
+  assert_parsed_expression_is("1ans", Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("ans", 3)));
   assert_parsed_expression_is("x1", Symbol::Builder("x1", 2));
-  assert_parsed_expression_is("1x+2", Addition::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1π", Multiplication::Builder(Rational::Builder(1),Constant::Builder(UCodePointGreekSmallLetterPi)));
-  assert_parsed_expression_is("1x-2", Subtraction::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
-  assert_parsed_expression_is("-1x", Opposite::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
-  assert_parsed_expression_is("2×1x", Multiplication::Builder(Rational::Builder(2),Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
-  assert_parsed_expression_is("2^1x", Multiplication::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(1)),Symbol::Builder("x", 1)));
-  assert_parsed_expression_is("1x^2", Multiplication::Builder(Rational::Builder(1),Power::Builder(Symbol::Builder("x", 1),Rational::Builder(2))));
-  assert_parsed_expression_is("2/1x", Division::Builder(Rational::Builder(2),Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
-  assert_parsed_expression_is("1x/2", Division::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
-  assert_parsed_expression_is("(1)2", Multiplication::Builder(Parenthesis::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1(2)", Multiplication::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("sin(1)2", Multiplication::Builder(Sine::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1cos(2)", Multiplication::Builder(Rational::Builder(1),Cosine::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!2", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("2ℯ^(3)", Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))));
-  assert_parsed_expression_is("\u00122^3\u00133", Multiplication::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(3)), Rational::Builder(3)));
-  Expression m1[] = {Rational::Builder(1)}; Matrix M1 = BuildMatrix(1,1,m1);
-  Expression m2[] = {Rational::Builder(2)}; Matrix M2 = BuildMatrix(1,1,m2);
+  assert_parsed_expression_is("1x+2", Addition::Builder(Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1π", Multiplication::Builder(BasedInteger::Builder(1),Constant::Builder(UCodePointGreekSmallLetterPi)));
+  assert_parsed_expression_is("1x-2", Subtraction::Builder(Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("-1x", Opposite::Builder(Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1))));
+  assert_parsed_expression_is("2×1x", Multiplication::Builder(BasedInteger::Builder(2),Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1))));
+  assert_parsed_expression_is("2^1x", Multiplication::Builder(Power::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)),Symbol::Builder("x", 1)));
+  assert_parsed_expression_is("1x^2", Multiplication::Builder(BasedInteger::Builder(1),Power::Builder(Symbol::Builder("x", 1),BasedInteger::Builder(2))));
+  assert_parsed_expression_is("2/1x", Division::Builder(BasedInteger::Builder(2),Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1))));
+  assert_parsed_expression_is("1x/2", Division::Builder(Multiplication::Builder(BasedInteger::Builder(1),Symbol::Builder("x", 1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("(1)2", Multiplication::Builder(Parenthesis::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1(2)", Multiplication::Builder(BasedInteger::Builder(1),Parenthesis::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("sin(1)2", Multiplication::Builder(Sine::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("1cos(2)", Multiplication::Builder(BasedInteger::Builder(1),Cosine::Builder(BasedInteger::Builder(2))));
+  assert_parsed_expression_is("1!2", Multiplication::Builder(Factorial::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("2ℯ^(3)", Multiplication::Builder(BasedInteger::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(BasedInteger::Builder(3)))));
+  assert_parsed_expression_is("\u00122^3\u00133", Multiplication::Builder(Power::Builder(BasedInteger::Builder(2),BasedInteger::Builder(3)), BasedInteger::Builder(3)));
+  Expression m1[] = {BasedInteger::Builder(1)}; Matrix M1 = BuildMatrix(1,1,m1);
+  Expression m2[] = {BasedInteger::Builder(2)}; Matrix M2 = BuildMatrix(1,1,m2);
   assert_parsed_expression_is("[[1]][[2]]", Multiplication::Builder(M1,M2));
 }
 
 QUIZ_CASE(poincare_parsing_adding_missing_parentheses) {
-  assert_parsed_expression_with_user_parentheses_is("1+-2", Addition::Builder(Rational::Builder(1),Parenthesis::Builder(Opposite::Builder(Rational::Builder(2)))));
-  assert_parsed_expression_with_user_parentheses_is("1--2", Subtraction::Builder(Rational::Builder(1),Parenthesis::Builder(Opposite::Builder(Rational::Builder(2)))));
-  assert_parsed_expression_with_user_parentheses_is("1+conj(-2)", Addition::Builder(Rational::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(2))))));
-  assert_parsed_expression_with_user_parentheses_is("1-conj(-2)", Subtraction::Builder(Rational::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(2))))));
-  assert_parsed_expression_with_user_parentheses_is("3conj(1+𝐢)", Multiplication::Builder(Rational::Builder(3), Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(1), Constant::Builder(UCodePointMathematicalBoldSmallI))))));
-  assert_parsed_expression_with_user_parentheses_is("2×-3", Multiplication::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3)))));
-  assert_parsed_expression_with_user_parentheses_is("2×-3", Multiplication::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3)))));
-  assert_parsed_expression_with_user_parentheses_is("--2", Opposite::Builder(Parenthesis::Builder(Opposite::Builder(Rational::Builder(2)))));
-  assert_parsed_expression_with_user_parentheses_is("\u00122/3\u0013^2", Power::Builder(Parenthesis::Builder(Division::Builder(Rational::Builder(2), Rational::Builder(3))), Rational::Builder(2)));
-  assert_parsed_expression_with_user_parentheses_is("log(1+-2)", CommonLogarithm::Builder(Addition::Builder(Rational::Builder(1),Parenthesis::Builder(Opposite::Builder(Rational::Builder(2))))));
+  assert_parsed_expression_with_user_parentheses_is("1+-2", Addition::Builder(BasedInteger::Builder(1),Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(2)))));
+  assert_parsed_expression_with_user_parentheses_is("1--2", Subtraction::Builder(BasedInteger::Builder(1),Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(2)))));
+  assert_parsed_expression_with_user_parentheses_is("1+conj(-2)", Addition::Builder(BasedInteger::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(2))))));
+  assert_parsed_expression_with_user_parentheses_is("1-conj(-2)", Subtraction::Builder(BasedInteger::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(2))))));
+  assert_parsed_expression_with_user_parentheses_is("3conj(1+𝐢)", Multiplication::Builder(BasedInteger::Builder(3), Parenthesis::Builder(Conjugate::Builder(Addition::Builder(BasedInteger::Builder(1), Constant::Builder(UCodePointMathematicalBoldSmallI))))));
+  assert_parsed_expression_with_user_parentheses_is("2×-3", Multiplication::Builder(BasedInteger::Builder(2), Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(3)))));
+  assert_parsed_expression_with_user_parentheses_is("2×-3", Multiplication::Builder(BasedInteger::Builder(2), Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(3)))));
+  assert_parsed_expression_with_user_parentheses_is("--2", Opposite::Builder(Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(2)))));
+  assert_parsed_expression_with_user_parentheses_is("\u00122/3\u0013^2", Power::Builder(Parenthesis::Builder(Division::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3))), BasedInteger::Builder(2)));
+  assert_parsed_expression_with_user_parentheses_is("log(1+-2)", CommonLogarithm::Builder(Addition::Builder(BasedInteger::Builder(1),Parenthesis::Builder(Opposite::Builder(BasedInteger::Builder(2))))));
 
   // Conjugate expressions
-  assert_parsed_expression_with_user_parentheses_is("conj(-3)+2", Addition::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(3))), Rational::Builder(2)));
-  assert_parsed_expression_with_user_parentheses_is("2+conj(-3)", Addition::Builder(Rational::Builder(2), Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(3))))));
-  assert_parsed_expression_with_user_parentheses_is("conj(-3)×2", Multiplication::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(3))), Rational::Builder(2)));
-  assert_parsed_expression_with_user_parentheses_is("2×conj(-3)", Multiplication::Builder(Rational::Builder(2), Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(3))))));
-  assert_parsed_expression_with_user_parentheses_is("conj(-3)-2", Subtraction::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(3))), Rational::Builder(2)));
-  assert_parsed_expression_with_user_parentheses_is("2-conj(-3)", Subtraction::Builder(Rational::Builder(2), Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(3))))));
-  assert_parsed_expression_with_user_parentheses_is("conj(2+3)^2", Power::Builder(Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(2), Rational::Builder(3)))), Rational::Builder(2)));
-  assert_parsed_expression_with_user_parentheses_is("-conj(2+3)", Opposite::Builder(Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(2), Rational::Builder(3))))));
-  assert_parsed_expression_with_user_parentheses_is("conj(2+3)!", Factorial::Builder(Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(2), Rational::Builder(3))))));
+  assert_parsed_expression_with_user_parentheses_is("conj(-3)+2", Addition::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(3))), BasedInteger::Builder(2)));
+  assert_parsed_expression_with_user_parentheses_is("2+conj(-3)", Addition::Builder(BasedInteger::Builder(2), Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(3))))));
+  assert_parsed_expression_with_user_parentheses_is("conj(-3)×2", Multiplication::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(3))), BasedInteger::Builder(2)));
+  assert_parsed_expression_with_user_parentheses_is("2×conj(-3)", Multiplication::Builder(BasedInteger::Builder(2), Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(3))))));
+  assert_parsed_expression_with_user_parentheses_is("conj(-3)-2", Subtraction::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(3))), BasedInteger::Builder(2)));
+  assert_parsed_expression_with_user_parentheses_is("2-conj(-3)", Subtraction::Builder(BasedInteger::Builder(2), Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(BasedInteger::Builder(3))))));
+  assert_parsed_expression_with_user_parentheses_is("conj(2+3)^2", Power::Builder(Parenthesis::Builder(Conjugate::Builder(Addition::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3)))), BasedInteger::Builder(2)));
+  assert_parsed_expression_with_user_parentheses_is("-conj(2+3)", Opposite::Builder(Parenthesis::Builder(Conjugate::Builder(Addition::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3))))));
+  assert_parsed_expression_with_user_parentheses_is("conj(2+3)!", Factorial::Builder(Parenthesis::Builder(Conjugate::Builder(Addition::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3))))));
 }
diff --git a/poincare/test/simplification.cpp b/poincare/test/simplification.cpp
index 1e3fba405..f253d5af8 100644
--- a/poincare/test/simplification.cpp
+++ b/poincare/test/simplification.cpp
@@ -3,6 +3,11 @@
 
 using namespace Poincare;
 
+QUIZ_CASE(poincare_simplification_based_integer) {
+  assert_parsed_expression_simplify_to("0b10011", "19");
+  assert_parsed_expression_simplify_to("0x2A", "42");
+}
+
 QUIZ_CASE(poincare_simplification_decimal) {
   assert_parsed_expression_simplify_to("-2.3", "-23/10");
   assert_parsed_expression_simplify_to("-232.2ᴇ-4", "-1161/50000");