diff --git a/C++ProjectTemplate b/C++ProjectTemplate
index c747ac0..ba98c90 100755
Binary files a/C++ProjectTemplate and b/C++ProjectTemplate differ
diff --git a/InfInt.h b/InfInt.h
new file mode 100644
index 0000000..da30418
--- /dev/null
+++ b/InfInt.h
@@ -0,0 +1,1371 @@
+/*
+ * InfInt - Arbitrary-Precision Integer Arithmetic Library
+ * Copyright (C) 2013 Sercan Tutar
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ * USAGE:
+ *   It is pretty straight forward to use the library. Just create an instance of
+ *   InfInt class and start using it.
+ *
+ *   Useful methods:
+ *      intSqrt:        integer square root operation
+ *      digitAt:        returns digit at index
+ *      numberOfDigits: returns number of digits
+ *      size:           returns size in bytes
+ *      toString:       converts it to a string
+ *
+ *   There are also conversion methods which allow conversion to primitive types:
+ *   toInt, toLong, toLongLong, toUnsignedInt, toUnsignedLong, toUnsignedLongLong.
+ *
+ *   You may define INFINT_USE_EXCEPTIONS and library methods will start raising
+ *   InfIntException in case of error instead of writing error messages using
+ *   std::cerr.
+ *
+ *   See ReadMe.txt for more info.
+ *
+ *
+ * No overflows, happy programmers!
+ *
+ */
+
+#ifndef INFINT_H_
+#define INFINT_H_
+
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <iomanip>
+#include <climits>
+
+//#include <limits.h>
+//#include <stdlib.h>
+
+#ifdef _WIN32
+#define LONG_LONG_MIN LLONG_MIN
+#define LONG_LONG_MAX LLONG_MAX
+#define ULONG_LONG_MAX ULLONG_MAX
+#endif
+
+#ifdef INFINT_USE_EXCEPTIONS
+#include <exception>
+#endif
+
+typedef int ELEM_TYPE;
+typedef long long PRODUCT_TYPE;
+static const ELEM_TYPE BASE = 1000000000;
+static const ELEM_TYPE UPPER_BOUND = 999999999;
+static const ELEM_TYPE DIGIT_COUNT = 9;
+static const int powersOfTen[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
+
+#ifdef INFINT_USE_EXCEPTIONS
+class InfIntException: public std::exception
+{
+public:
+    InfIntException(const std::string& txt) throw ();
+    ~InfIntException() throw ();
+    const char* what() const throw ();
+private:
+    std::string txt;
+};
+
+inline InfIntException::InfIntException(const std::string& txt) throw () :
+std::exception(), txt(txt)
+{
+}
+
+inline InfIntException::~InfIntException() throw ()
+{
+}
+
+inline const char* InfIntException::what() const throw ()
+{
+    return txt.c_str();
+}
+#endif
+
+inline static div_t my_div(int num, int denom)
+{
+    div_t result;
+    result.quot = num / denom;
+    result.rem = num - denom * result.quot;
+    return result;
+}
+
+inline static ldiv_t my_ldiv(long num, long denom)
+{
+    ldiv_t result;
+    result.quot = num / denom;
+    result.rem = num - denom * result.quot;
+    return result;
+}
+
+inline static lldiv_t my_lldiv(long long num, long long denom)
+{
+    lldiv_t result;
+    result.quot = num / denom;
+    result.rem = num - denom * result.quot;
+    return result;
+}
+
+class InfInt
+{
+    friend std::ostream& operator<<(std::ostream &s, const InfInt &n);
+    friend std::istream& operator>>(std::istream &s, InfInt &val);
+
+public:
+    /* constructors */
+    InfInt();
+    InfInt(const char* c);
+    InfInt(const std::string& s);
+    InfInt(int l);
+    InfInt(long l);
+    InfInt(long long l);
+    InfInt(unsigned int l);
+    InfInt(unsigned long l);
+    InfInt(unsigned long long l);
+    InfInt(const InfInt& l);
+
+    /* assignment operators */
+    const InfInt& operator=(const char* c);
+    const InfInt& operator=(const std::string& s);
+    const InfInt& operator=(int l);
+    const InfInt& operator=(long l);
+    const InfInt& operator=(long long l);
+    const InfInt& operator=(unsigned int l);
+    const InfInt& operator=(unsigned long l);
+    const InfInt& operator=(unsigned long long l);
+    const InfInt& operator=(const InfInt& l);
+
+    /* unary increment/decrement operators */
+    const InfInt& operator++();
+    const InfInt& operator--();
+    InfInt operator++(int);
+    InfInt operator--(int);
+
+    /* operational assignments */
+    const InfInt& operator+=(const InfInt& rhs);
+    const InfInt& operator-=(const InfInt& rhs);
+    const InfInt& operator*=(const InfInt& rhs);
+    const InfInt& operator/=(const InfInt& rhs); // throw
+    const InfInt& operator%=(const InfInt& rhs); // throw
+    const InfInt& operator*=(ELEM_TYPE rhs);
+
+    /* operations */
+    InfInt operator-() const;
+    InfInt operator+(const InfInt& rhs) const;
+    InfInt operator-(const InfInt& rhs) const;
+    InfInt operator*(const InfInt& rhs) const;
+    InfInt operator/(const InfInt& rhs) const; // throw
+    InfInt operator%(const InfInt& rhs) const; // throw
+    InfInt operator*(ELEM_TYPE rhs) const;
+
+    /* relational operations */
+    bool operator==(const InfInt& rhs) const;
+    bool operator!=(const InfInt& rhs) const;
+    bool operator<(const InfInt& rhs) const;
+    bool operator<=(const InfInt& rhs) const;
+    bool operator>(const InfInt& rhs) const;
+    bool operator>=(const InfInt& rhs) const;
+
+    /* integer square root */
+    InfInt intSqrt() const; // throw
+
+    /* digit operations */
+    char digitAt(size_t i) const; // throw
+    size_t numberOfDigits() const;
+
+    /* size in bytes */
+    size_t size() const;
+
+    /* string conversion */
+    std::string toString() const;
+
+    /* conversion to primitive types */
+    int toInt() const; // throw
+    long toLong() const; // throw
+    long long toLongLong() const; // throw
+    unsigned int toUnsignedInt() const; // throw
+    unsigned long toUnsignedLong() const; // throw
+    unsigned long long toUnsignedLongLong() const; // throw
+
+private:
+    static ELEM_TYPE dInR(const InfInt& R, const InfInt& D);
+    static void multiplyByDigit(ELEM_TYPE factor, std::vector<ELEM_TYPE>& val);
+
+    void correct(bool justCheckLeadingZeros = false, bool hasValidSign = false);
+    void fromString(const std::string& s);
+    void optimizeSqrtSearchBounds(InfInt& lo, InfInt& hi) const;
+    void truncateToBase();
+    bool equalizeSigns();
+    void removeLeadingZeros();
+
+    std::vector<ELEM_TYPE> val; // number with base FACTOR
+    bool pos; // true if number is positive
+};
+
+inline InfInt::InfInt() : pos(true)
+{
+    //PROFINY_SCOPE
+    val.push_back((ELEM_TYPE) 0);
+}
+
+inline InfInt::InfInt(const char* c)
+{
+    //PROFINY_SCOPE
+    fromString(c);
+}
+
+inline InfInt::InfInt(const std::string& s)
+{
+    //PROFINY_SCOPE
+    fromString(s);
+}
+
+inline InfInt::InfInt(int l) : pos(l >= 0)
+{
+    //PROFINY_SCOPE
+    bool subtractOne = false;
+    if (l == INT_MIN)
+    {
+        subtractOne = true;
+        ++l;
+    }
+
+    if (!pos)
+    {
+        l = -l;
+    }
+    do
+    {
+        div_t dt = my_div(l, BASE);
+        val.push_back((ELEM_TYPE) dt.rem);
+        l = dt.quot;
+    } while (l > 0);
+
+    if (subtractOne)
+    {
+        --*this;
+    }
+}
+
+inline InfInt::InfInt(long l) : pos(l >= 0)
+{
+    //PROFINY_SCOPE
+    bool subtractOne = false;
+    if (l == LONG_MIN)
+    {
+        subtractOne = true;
+        ++l;
+    }
+
+    if (!pos)
+    {
+        l = -l;
+    }
+    do
+    {
+        ldiv_t dt = my_ldiv(l, BASE);
+        val.push_back((ELEM_TYPE) dt.rem);
+        l = dt.quot;
+    } while (l > 0);
+
+    if (subtractOne)
+    {
+        --*this;
+    }
+}
+
+inline InfInt::InfInt(long long l) : pos(l >= 0)
+{
+    //PROFINY_SCOPE
+    bool subtractOne = false;
+    if (l == LONG_LONG_MIN)
+    {
+        subtractOne = true;
+        ++l;
+    }
+
+    if (!pos)
+    {
+        l = -l;
+    }
+    do
+    {
+        lldiv_t dt = my_lldiv(l, BASE);
+        val.push_back((ELEM_TYPE) dt.rem);
+        l = dt.quot;
+    } while (l > 0);
+
+    if (subtractOne)
+    {
+        --*this;
+    }
+}
+
+inline InfInt::InfInt(unsigned int l) : pos(true)
+{
+    //PROFINY_SCOPE
+    do
+    {
+        val.push_back((ELEM_TYPE) (l % BASE));
+        l = l / BASE;
+    } while (l > 0);
+}
+
+inline InfInt::InfInt(unsigned long l) : pos(true)
+{
+    //PROFINY_SCOPE
+    do
+    {
+        val.push_back((ELEM_TYPE) (l % BASE));
+        l = l / BASE;
+    } while (l > 0);
+}
+
+inline InfInt::InfInt(unsigned long long l) : pos(true)
+{
+    //PROFINY_SCOPE
+    do
+    {
+        val.push_back((ELEM_TYPE) (l % BASE));
+        l = l / BASE;
+    } while (l > 0);
+}
+
+inline InfInt::InfInt(const InfInt& l) : pos(l.pos), val(l.val)
+{
+    //PROFINY_SCOPE
+}
+
+inline const InfInt& InfInt::operator=(const char* c)
+{
+    //PROFINY_SCOPE
+    fromString(c);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator=(const std::string& s)
+{
+    //PROFINY_SCOPE
+    fromString(s);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator=(int l)
+{
+    //PROFINY_SCOPE
+    bool subtractOne = false;
+    if (l == INT_MIN)
+    {
+        subtractOne = true;
+        ++l;
+    }
+
+    pos = l >= 0;
+    val.clear();
+    if (!pos)
+    {
+        l = -l;
+    }
+    do
+    {
+        div_t dt = my_div(l, BASE);
+        val.push_back((ELEM_TYPE) dt.rem);
+        l = dt.quot;
+    } while (l > 0);
+
+    return subtractOne ? --*this : *this;
+}
+
+inline const InfInt& InfInt::operator=(long l)
+{
+    //PROFINY_SCOPE
+    bool subtractOne = false;
+    if (l == LONG_MIN)
+    {
+        subtractOne = true;
+        ++l;
+    }
+
+    pos = l >= 0;
+    val.clear();
+    if (!pos)
+    {
+        l = -l;
+    }
+    do
+    {
+        ldiv_t dt = my_ldiv(l, BASE);
+        val.push_back((ELEM_TYPE) dt.rem);
+        l = dt.quot;
+    } while (l > 0);
+
+    return subtractOne ? --*this : *this;
+}
+
+inline const InfInt& InfInt::operator=(long long l)
+{
+    //PROFINY_SCOPE
+    bool subtractOne = false;
+    if (l == LONG_LONG_MIN)
+    {
+        subtractOne = true;
+        ++l;
+    }
+
+    pos = l >= 0;
+    val.clear();
+    if (!pos)
+    {
+        l = -l;
+    }
+    do
+    {
+        lldiv_t dt = my_lldiv(l, BASE);
+        val.push_back((ELEM_TYPE) dt.rem);
+        l = dt.quot;
+    } while (l > 0);
+
+    return subtractOne ? --*this : *this;
+}
+
+inline const InfInt& InfInt::operator=(unsigned int l)
+{
+    //PROFINY_SCOPE
+    pos = true;
+    val.clear();
+    do
+    {
+        val.push_back((ELEM_TYPE) (l % BASE));
+        l = l / BASE;
+    } while (l > 0);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator=(unsigned long l)
+{
+    //PROFINY_SCOPE
+    pos = true;
+    val.clear();
+    do
+    {
+        val.push_back((ELEM_TYPE) (l % BASE));
+        l = l / BASE;
+    } while (l > 0);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator=(unsigned long long l)
+{
+    //PROFINY_SCOPE
+    pos = true;
+    val.clear();
+    do
+    {
+        val.push_back((ELEM_TYPE) (l % BASE));
+        l = l / BASE;
+    } while (l > 0);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator=(const InfInt& l)
+{
+    //PROFINY_SCOPE
+    pos = l.pos;
+    val = l.val;
+    return *this;
+}
+
+inline const InfInt& InfInt::operator++()
+{
+    //PROFINY_SCOPE
+    val[0] += (pos ? 1 : -1);
+    this->correct(false, true);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator--()
+{
+    //PROFINY_SCOPE
+    val[0] -= (pos ? 1 : -1);
+    this->correct(false, true);
+    return *this;
+}
+
+inline InfInt InfInt::operator++(int)
+{
+    //PROFINY_SCOPE
+    InfInt result = *this;
+    val[0] += (pos ? 1 : -1);
+    this->correct(false, true);
+    return result;
+}
+
+inline InfInt InfInt::operator--(int)
+{
+    //PROFINY_SCOPE
+    InfInt result = *this;
+    val[0] -= (pos ? 1 : -1);
+    this->correct(false, true);
+    return result;
+}
+
+inline const InfInt& InfInt::operator+=(const InfInt& rhs)
+{
+    //PROFINY_SCOPE
+    if (rhs.val.size() > val.size())
+    {
+        val.resize(rhs.val.size(), 0);
+    }
+    for (size_t i = 0; i < val.size(); ++i)
+    {
+        val[i] = (pos ? val[i] : -val[i]) + (i < rhs.val.size() ? (rhs.pos ? rhs.val[i] : -rhs.val[i]) : 0);
+    }
+    correct();
+    return *this;
+}
+
+inline const InfInt& InfInt::operator-=(const InfInt& rhs)
+{
+    //PROFINY_SCOPE
+    if (rhs.val.size() > val.size())
+    {
+        val.resize(rhs.val.size(), 0);
+    }
+    for (size_t i = 0; i < val.size(); ++i)
+    {
+        val[i] = (pos ? val[i] : -val[i]) - (i < rhs.val.size() ? (rhs.pos ? rhs.val[i] : -rhs.val[i]) : 0);
+    }
+    correct();
+    return *this;
+}
+
+inline const InfInt& InfInt::operator*=(const InfInt& rhs)
+{
+    //PROFINY_SCOPE
+    // TODO: optimize (do not use operator*)
+    *this = *this * rhs;
+    return *this;
+}
+
+inline const InfInt& InfInt::operator/=(const InfInt& rhs)
+{
+    //PROFINY_SCOPE
+    if (rhs == 0)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("division by zero");
+#else
+        std::cerr << "Division by zero!" << std::endl;
+        return *this;
+#endif
+    }
+    InfInt R, D = (rhs.pos ? rhs : -rhs), N = (pos ? *this : -*this);
+    bool oldpos = pos;
+    std::fill(val.begin(), val.end(), 0);
+    for (int i = (int) N.val.size() - 1; i >= 0; --i)
+    {
+        R.val.insert(R.val.begin(), N.val[i]);
+        R.correct(true);
+        ELEM_TYPE cnt = dInR(R, D);
+        R -= D * cnt;
+        val[i] += cnt;
+    }
+    correct();
+    pos = (val.size() == 1 && val[0] == 0) ? true : (oldpos == rhs.pos);
+    return *this;
+}
+
+inline const InfInt& InfInt::operator%=(const InfInt& rhs)
+{
+    //PROFINY_SCOPE
+    // TODO: optimize (do not use operator%)
+    *this = *this % rhs;
+    return *this;
+//    if (rhs == 0)
+//    {
+//#ifdef INFINT_USE_EXCEPTIONS
+//        throw InfIntException("division by zero");
+//#else
+//        std::cerr << "Division by zero!" << std::endl;
+//        return *this;
+//#endif
+//    }
+//    InfInt D = (rhs.pos ? rhs : -rhs), N = (pos ? *this : -*this);
+//    bool oldpos = pos;
+//    val.clear();
+//    for (int i = (int) N.val.size() - 1; i >= 0; --i)
+//    {
+//        val.insert(val.begin(), N.val[i]);
+//        correct(true);
+//        *this -= D * dInR(*this, D);
+//    }
+//    correct();
+//    pos = (val.size() == 1 && val[0] == 0) ? true : oldpos;
+//    return *this;
+}
+
+inline const InfInt& InfInt::operator*=(ELEM_TYPE rhs)
+{
+    //PROFINY_SCOPE
+    ELEM_TYPE factor = rhs < 0 ? -rhs : rhs;
+    bool oldpos = pos;
+    multiplyByDigit(factor, val);
+    correct();
+    pos = (val.size() == 1 && val[0] == 0) ? true : (oldpos == (rhs >= 0));
+    return *this;
+}
+
+inline InfInt InfInt::operator-() const
+{
+    //PROFINY_SCOPE
+    InfInt result = *this;
+    result.pos = !pos;
+    return result;
+}
+
+inline InfInt InfInt::operator+(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    InfInt result;
+    result.val.resize(val.size() > rhs.val.size() ? val.size() : rhs.val.size(), 0);
+    for (size_t i = 0; i < val.size() || i < rhs.val.size(); ++i)
+    {
+        result.val[i] = (i < val.size() ? (pos ? val[i] : -val[i]) : 0) + (i < rhs.val.size() ? (rhs.pos ? rhs.val[i] : -rhs.val[i]) : 0);
+    }
+    result.correct();
+    return result;
+}
+
+inline InfInt InfInt::operator-(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    InfInt result;
+    result.val.resize(val.size() > rhs.val.size() ? val.size() : rhs.val.size(), 0);
+    for (size_t i = 0; i < val.size() || i < rhs.val.size(); ++i)
+    {
+        result.val[i] = (i < val.size() ? (pos ? val[i] : -val[i]) : 0) - (i < rhs.val.size() ? (rhs.pos ? rhs.val[i] : -rhs.val[i]) : 0);
+    }
+    result.correct();
+    return result;
+}
+
+inline InfInt InfInt::operator*(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    InfInt result;
+    result.val.resize(val.size() + rhs.val.size(), 0);
+    PRODUCT_TYPE carry = 0;
+    size_t digit = 0;
+    for (;; ++digit)
+    {
+        lldiv_t dt = my_lldiv(carry, BASE);
+        carry = dt.quot;
+        result.val[digit] = (ELEM_TYPE) dt.rem;
+
+        bool found = false;
+        for (size_t i = digit < rhs.val.size() ? 0 : digit - rhs.val.size() + 1; i < val.size() && i <= digit; ++i)
+        {
+            PRODUCT_TYPE pval = result.val[digit] + val[i] * (PRODUCT_TYPE) rhs.val[digit - i];
+            if (pval >= BASE || pval <= -BASE)
+            {
+                lldiv_t dt = my_lldiv(pval, BASE);
+                carry += dt.quot;
+                pval = dt.rem;
+            }
+            result.val[digit] = (ELEM_TYPE) pval;
+            found = true;
+        }
+        if (!found)
+        {
+            break;
+        }
+    }
+    for (; carry > 0; ++digit)
+    {
+        lldiv_t dt = my_lldiv(carry, BASE);
+        result.val[digit] = (ELEM_TYPE) dt.rem;
+        carry = dt.quot;
+    }
+    result.correct();
+    result.pos = (result.val.size() == 1 && result.val[0] == 0) ? true : (pos == rhs.pos);
+    return result;
+}
+
+inline InfInt InfInt::operator/(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (rhs == 0)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("division by zero");
+#else
+        std::cerr << "Division by zero!" << std::endl;
+        return 0;
+#endif
+    }
+    InfInt Q, R, D = (rhs.pos ? rhs : -rhs), N = (pos ? *this : -*this);
+    Q.val.resize(N.val.size(), 0);
+    for (int i = (int) N.val.size() - 1; i >= 0; --i)
+    {
+        R.val.insert(R.val.begin(), N.val[i]);
+        R.correct(true);
+        ELEM_TYPE cnt = dInR(R, D);
+        R -= D * cnt;
+        Q.val[i] += cnt;
+    }
+    Q.correct();
+    Q.pos = (Q.val.size() == 1 && Q.val[0] == 0) ? true : (pos == rhs.pos);
+    return Q;
+}
+
+inline InfInt InfInt::operator%(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (rhs == 0)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("division by zero");
+#else
+        std::cerr << "Division by zero!" << std::endl;
+        return 0;
+#endif
+    }
+    InfInt R, D = (rhs.pos ? rhs : -rhs), N = (pos ? *this : -*this);
+    for (int i = (int) N.val.size() - 1; i >= 0; --i)
+    {
+        R.val.insert(R.val.begin(), N.val[i]);
+        R.correct(true);
+        R -= D * dInR(R, D);
+    }
+    R.correct();
+    R.pos = (R.val.size() == 1 && R.val[0] == 0) ? true : pos;
+    return R;
+}
+
+inline InfInt InfInt::operator*(ELEM_TYPE rhs) const
+{
+    //PROFINY_SCOPE
+    InfInt result = *this;
+    ELEM_TYPE factor = rhs < 0 ? -rhs : rhs;
+    multiplyByDigit(factor, result.val);
+    result.correct();
+    result.pos = (result.val.size() == 1 && result.val[0] == 0) ? true : (pos == (rhs >= 0));
+    return result;
+}
+
+inline bool InfInt::operator==(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (pos != rhs.pos || val.size() != rhs.val.size())
+    {
+        return false;
+    }
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        if (val[i] != rhs.val[i])
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+inline bool InfInt::operator!=(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (pos != rhs.pos || val.size() != rhs.val.size())
+    {
+        return true;
+    }
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        if (val[i] != rhs.val[i])
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+inline bool InfInt::operator<(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (pos && !rhs.pos)
+    {
+        return false;
+    }
+    if (!pos && rhs.pos)
+    {
+        return true;
+    }
+    if (val.size() > rhs.val.size())
+    {
+        return pos ? false : true;
+    }
+    if (val.size() < rhs.val.size())
+    {
+        return pos ? true : false;
+    }
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        if (val[i] < rhs.val[i])
+        {
+            return pos ? true : false;
+        }
+        if (val[i] > rhs.val[i])
+        {
+            return pos ? false : true;
+        }
+    }
+    return false;
+}
+
+inline bool InfInt::operator<=(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (pos && !rhs.pos)
+    {
+        return false;
+    }
+    if (!pos && rhs.pos)
+    {
+        return true;
+    }
+    if (val.size() > rhs.val.size())
+    {
+        return pos ? false : true;
+    }
+    if (val.size() < rhs.val.size())
+    {
+        return pos ? true : false;
+    }
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        if (val[i] < rhs.val[i])
+        {
+            return pos ? true : false;
+        }
+        if (val[i] > rhs.val[i])
+        {
+            return pos ? false : true;
+        }
+    }
+    return true;
+}
+
+inline bool InfInt::operator>(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (pos && !rhs.pos)
+    {
+        return true;
+    }
+    if (!pos && rhs.pos)
+    {
+        return false;
+    }
+    if (val.size() > rhs.val.size())
+    {
+        return pos ? true : false;
+    }
+    if (val.size() < rhs.val.size())
+    {
+        return pos ? false : true;
+    }
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        if (val[i] < rhs.val[i])
+        {
+            return pos ? false : true;
+        }
+        if (val[i] > rhs.val[i])
+        {
+            return pos ? true : false;
+        }
+    }
+    return false;
+}
+
+inline bool InfInt::operator>=(const InfInt& rhs) const
+{
+    //PROFINY_SCOPE
+    if (pos && !rhs.pos)
+    {
+        return true;
+    }
+    if (!pos && rhs.pos)
+    {
+        return false;
+    }
+    if (val.size() > rhs.val.size())
+    {
+        return pos ? true : false;
+    }
+    if (val.size() < rhs.val.size())
+    {
+        return pos ? false : true;
+    }
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        if (val[i] < rhs.val[i])
+        {
+            return pos ? false : true;
+        }
+        if (val[i] > rhs.val[i])
+        {
+            return pos ? true : false;
+        }
+    }
+    return true;
+}
+
+inline void InfInt::optimizeSqrtSearchBounds(InfInt& lo, InfInt& hi) const
+{
+    //PROFINY_SCOPE
+    InfInt hdn = 1;
+    for (int i = (int) this->numberOfDigits() / 2; i >= 2; --i)
+    {
+        hdn *= 10;
+    }
+    if (lo < hdn)
+    {
+        lo = hdn;
+    }
+    hdn *= 100;
+    if (hi > hdn)
+    {
+        hi = hdn;
+    }
+}
+
+inline InfInt InfInt::intSqrt() const
+{
+    //PROFINY_SCOPE
+    if (*this <= 0)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("intSqrt called for non-positive integer");
+#else
+        std::cerr << "intSqrt called for non-positive integer: " << *this << std::endl;
+        return 0;
+#endif
+    }
+    InfInt hi = *this / 2 + 1, lo = 0, mid, mid2;
+    optimizeSqrtSearchBounds(lo, hi);
+    do
+    {
+        mid = (hi + lo) / 2; // 8 factor
+        mid2 = mid * mid; // 1 factor
+        if (mid2 == *this)
+        {
+            lo = mid;
+            break;
+        }
+        else if (mid2 < *this)
+        {
+            lo = mid;
+        }
+        else
+        {
+            hi = mid;
+        }
+    } while (lo < hi - 1 && mid2 != *this);
+    return lo;
+}
+
+inline char InfInt::digitAt(size_t i) const
+{
+    //PROFINY_SCOPE
+    if (numberOfDigits() <= i)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("invalid digit index");
+#else
+        std::cerr << "Invalid digit index: " << i << std::endl;
+        return -1;
+#endif
+    }
+    return (val[i / DIGIT_COUNT] / powersOfTen[i % DIGIT_COUNT]) % 10;
+}
+
+inline size_t InfInt::numberOfDigits() const
+{
+    //PROFINY_SCOPE
+    return (val.size() - 1) * DIGIT_COUNT +
+        (val.back() > 99999999 ? 9 : (val.back() > 9999999 ? 8 : (val.back() > 999999 ? 7 : (val.back() > 99999 ? 6 :
+        (val.back() > 9999 ? 5 : (val.back() > 999 ? 4 : (val.back() > 99 ? 3 : (val.back() > 9 ? 2 : 1))))))));
+}
+
+inline std::string InfInt::toString() const
+{
+    //PROFINY_SCOPE
+    std::ostringstream oss;
+    oss << *this;
+    return oss.str();
+}
+
+inline size_t InfInt::size() const
+{
+    //PROFINY_SCOPE
+    return val.size() * sizeof(ELEM_TYPE) + sizeof(bool);
+}
+
+inline int InfInt::toInt() const
+{
+    //PROFINY_SCOPE
+    if (*this > INT_MAX || *this < INT_MIN)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("out of bounds");
+#else
+        std::cerr << "Out of INT bounds: " << *this << std::endl;
+#endif
+    }
+    int result = 0;
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        result = result * BASE + val[i];
+    }
+    return pos ? result : -result;
+}
+
+inline long InfInt::toLong() const
+{
+    //PROFINY_SCOPE
+    if (*this > LONG_MAX || *this < LONG_MIN)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("out of bounds");
+#else
+        std::cerr << "Out of LONG bounds: " << *this << std::endl;
+#endif
+    }
+    long result = 0;
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        result = result * BASE + val[i];
+    }
+    return pos ? result : -result;
+}
+
+inline long long InfInt::toLongLong() const
+{
+    //PROFINY_SCOPE
+    if (*this > LONG_LONG_MAX || *this < LONG_LONG_MIN)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("out of bounds");
+#else
+        std::cerr << "Out of LLONG bounds: " << *this << std::endl;
+#endif
+    }
+    long long result = 0;
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        result = result * BASE + val[i];
+    }
+    return pos ? result : -result;
+}
+
+inline unsigned int InfInt::toUnsignedInt() const
+{
+    //PROFINY_SCOPE
+    if (!pos || *this > UINT_MAX)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("out of bounds");
+#else
+        std::cerr << "Out of UINT bounds: " << *this << std::endl;
+#endif
+    }
+    unsigned int result = 0;
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        result = result * BASE + val[i];
+    }
+    return result;
+}
+
+inline unsigned long InfInt::toUnsignedLong() const
+{
+    //PROFINY_SCOPE
+    if (!pos || *this > ULONG_MAX)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("out of bounds");
+#else
+        std::cerr << "Out of ULONG bounds: " << *this << std::endl;
+#endif
+    }
+    unsigned long result = 0;
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        result = result * BASE + val[i];
+    }
+    return result;
+}
+
+inline unsigned long long InfInt::toUnsignedLongLong() const
+{
+    //PROFINY_SCOPE
+    if (!pos || *this > ULONG_LONG_MAX)
+    {
+#ifdef INFINT_USE_EXCEPTIONS
+        throw InfIntException("out of bounds");
+#else
+        std::cerr << "Out of ULLONG bounds: " << *this << std::endl;
+#endif
+    }
+    unsigned long long result = 0;
+    for (int i = (int) val.size() - 1; i >= 0; --i)
+    {
+        result = result * BASE + val[i];
+    }
+    return result;
+}
+
+inline void InfInt::truncateToBase()
+{
+    //PROFINY_SCOPE
+    for (size_t i = 0; i < val.size(); ++i) // truncate each
+    {
+        if (val[i] >= BASE || val[i] <= -BASE)
+        {
+            div_t dt = my_div(val[i], BASE);
+            val[i] = dt.rem;
+            if (i + 1 >= val.size())
+            {
+                val.push_back(dt.quot);
+            }
+            else
+            {
+                val[i + 1] += dt.quot;
+            }
+        }
+    }
+}
+
+inline bool InfInt::equalizeSigns()
+{
+    //PROFINY_SCOPE
+    bool isPositive = true;
+    int i = (int) ((val.size())) - 1;
+    for (; i >= 0; --i)
+    {
+        if (val[i] != 0)
+        {
+            isPositive = val[i--] > 0;
+            break;
+        }
+    }
+
+    if (isPositive)
+    {
+        for (; i >= 0; --i)
+        {
+            if (val[i] < 0)
+            {
+                int k = 0, index = i + 1;
+                for (; (size_t)(index) < val.size() && val[index] == 0; ++k, ++index)
+                    ; // count adjacent zeros on left
+                //if ((size_t)(index) < val.size() && val[index] > 0)
+                { // number on the left is positive
+                    val[index] -= 1;
+                    val[i] += BASE;
+                    for (; k > 0; --k)
+                    {
+                        val[i + k] = UPPER_BOUND;
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        for (; i >= 0; --i)
+        {
+            if (val[i] > 0)
+            {
+                int k = 0, index = i + 1;
+                for (; (size_t)(index) < val.size() && val[index] == 0; ++k, ++index)
+                    ; // count adjacent zeros on right
+                //if ((size_t)(index) < val.size() && val[index] < 0)
+                { // number on the left is negative
+                    val[index] += 1;
+                    val[i] -= BASE;
+                    for (; k > 0; --k)
+                    {
+                        val[i + k] = -UPPER_BOUND;
+                    }
+                }
+            }
+        }
+    }
+    
+    return isPositive;
+}
+
+inline void InfInt::removeLeadingZeros()
+{
+    //PROFINY_SCOPE
+    for (int i = (int) (val.size()) - 1; i > 0; --i) // remove leading 0's
+    {
+        if (val[i] != 0)
+        {
+            return;
+        }
+        else
+        {
+            val.erase(val.begin() + i);
+        }
+    }
+}
+
+inline void InfInt::correct(bool justCheckLeadingZeros, bool hasValidSign)
+{
+    //PROFINY_SCOPE
+    if (!justCheckLeadingZeros)
+    {
+        truncateToBase();
+        
+        if (equalizeSigns())
+        {
+            pos = ((val.size() == 1 && val[0] == 0) || !hasValidSign) ? true : pos;
+        }
+        else
+        {
+            pos = hasValidSign ? !pos : false;
+            for (size_t i = 0; i < val.size(); ++i)
+            {
+                val[i] = abs(val[i]);
+            }
+        }
+    }
+    
+    removeLeadingZeros();
+}
+
+inline void InfInt::fromString(const std::string& s)
+{
+    //PROFINY_SCOPE
+    pos = true;
+    val.clear();
+    val.reserve(s.size() / DIGIT_COUNT + 1);
+    int i = (int) s.size() - DIGIT_COUNT;
+    for (; i >= 0; i -= DIGIT_COUNT)
+    {
+        val.push_back(atoi(s.substr(i, DIGIT_COUNT).c_str()));
+    }
+    if (i > -DIGIT_COUNT)
+    {
+        std::string ss = s.substr(0, i + DIGIT_COUNT);
+        if (ss.size() == 1 && ss[0] == '-')
+        {
+            pos = false;
+        }
+        else
+        {
+            val.push_back(atoi(ss.c_str()));
+        }
+    }
+    if (val.back() < 0)
+    {
+        val.back() = -val.back();
+        pos = false;
+    }
+    correct(true);
+}
+
+inline ELEM_TYPE InfInt::dInR(const InfInt& R, const InfInt& D)
+{
+    //PROFINY_SCOPE
+    ELEM_TYPE min = 0, max = UPPER_BOUND;
+    while (max > min)
+    {
+        ELEM_TYPE avg = max + min;
+        div_t dt = my_div(avg, 2);
+        avg = dt.rem ? (dt.quot + 1) : dt.quot;
+        InfInt prod = D * avg;
+        if (R == prod)
+        {
+            return avg;
+        }
+        else if (R > prod)
+        {
+            min = avg;
+        }
+        else
+        {
+            max = avg - 1;
+        }
+    }
+    return min;
+}
+
+inline void InfInt::multiplyByDigit(ELEM_TYPE factor, std::vector<ELEM_TYPE>& val)
+{
+    //PROFINY_SCOPE
+    ELEM_TYPE carry = 0;
+    for (size_t i = 0; i < val.size(); ++i)
+    {
+        PRODUCT_TYPE pval = val[i] * (PRODUCT_TYPE) factor + carry;
+        if (pval >= BASE || pval <= -BASE)
+        {
+            lldiv_t dt = my_lldiv(pval, BASE);
+            carry = (ELEM_TYPE) dt.quot;
+            pval = dt.rem;
+        }
+        else
+        {
+            carry = 0;
+        }
+        val[i] = (ELEM_TYPE) pval;
+    }
+    if (carry > 0)
+    {
+        val.push_back(carry);
+    }
+}
+
+/**************************************************************/
+/******************** NON-MEMBER OPERATORS ********************/
+/**************************************************************/
+
+inline std::istream& operator>>(std::istream &s, InfInt &n)
+{
+    //PROFINY_SCOPE
+    std::string str;
+    s >> str;
+    n.fromString(str);
+    return s;
+}
+
+inline std::ostream& operator<<(std::ostream &s, const InfInt &n)
+{
+    //PROFINY_SCOPE
+    if (!n.pos)
+    {
+        s << '-';
+    }
+    bool first = true;
+    for (int i = (int) n.val.size() - 1; i >= 0; --i)
+    {
+        if (first)
+        {
+            s << n.val[i];
+            first = false;
+        }
+        else
+        {
+            s << std::setfill('0') << std::setw(DIGIT_COUNT) << n.val[i];
+        }
+    }
+    return s;
+}
+
+#endif
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
index 88f303b..5ac897d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,14 +1,95 @@
 #define OLC_PGE_APPLICATION
 #include "pixelGameEngine.h"
 #include "olcutils.h"
-#include "BigInt.h"
+#include "InfInt.h"
 
 using namespace olc;
-// C++ program to implement
-// the above approach
+
+
+//Break down each number into its raw factors.
+//The number itself is also stored.
+//If the factorization is larger than 19, we can discard it. It shouldn't matter.
+
+std::vector<int>factor(int numb){
+    std::vector<int>factors;
+    while (numb>1){
+        for (int i=2;i<numb;i++){
+            if (numb%i==0){
+                factors.push_back(i);
+                numb/=i;
+                goto next;
+            }
+        }
+        factors.push_back(numb);
+        numb/=numb;
+        next:;
+    }
+    factors.push_back(1);
+    return factors;
+}
+
+struct factorNumber{
+    void SetupOffsets(){
+        offsets.push_back({23,0});
+        offsets.push_back({19,0});
+        offsets.push_back({13,0});
+        offsets.push_back({17,0});
+    }
+    std::vector<int>factors;
+    std::vector<std::pair<int,int>>offsets;
+    factorNumber(int numb){
+        SetupOffsets();
+    }
+    factorNumber&operator=(int numb){
+        factors.clear();
+        offsets.clear();
+        SetupOffsets();
+        factors=factor(numb);
+        return*this;
+    }
+    factorNumber&operator+=(int numb){
+        for (int i=0;i<offsets.size();i++){
+            std::pair<int,int>&offset=offsets[i];
+            offset.second=(offset.second+numb)%offset.first;
+        }
+        return*this;
+    }
+    factorNumber&operator*=(int numb){
+        std::vector<int>factors=factor(numb);
+        for (int i=0;i<factors.size();i++){
+            for (int j=0;j<this->factors.size();j++){
+                if (this->factors[j]==factors[i]){
+                    goto gonext;
+                }
+            }
+            this->factors.push_back(factors[i]);
+            gonext:;
+        }
+        return*this;
+    }
+    int operator%(int numb){
+        for (int i=0;i<offsets.size();i++){
+            if (offsets[i].first==numb){
+                if (offsets[i].second==0) {
+                    for (int j=0;j<factors.size();j++){
+                        if (factors[j]==numb){
+                            return 0;
+                        }
+                    }
+                    //std::cout<<"Not divisible!"<<std::endl;
+                    return -1;
+                } else {
+                    return offsets[i].second;
+                }
+            }
+        }
+        std::cout<<"No divisibility information for modulus "<<numb<<" !! THIS SHOULDN'T BE HAPPENING !!"<<std::endl;
+        return -1; //This shouldn't happen??
+    }
+};
 
 struct Monkey{
-    std::vector<BigInt> items;
+    std::vector<factorNumber> items;
     char operation;
     int operation_amt;
     int divisible;
@@ -22,22 +103,26 @@ int main()
     std::vector<Monkey> monkeys;
 	std::ifstream file("input");
 
-    monkeys.push_back({{89,95,92,64,87,68},'*',11,2,7,4});
+    /*monkeys.push_back({{89,95,92,64,87,68},'*',11,2,7,4});
     monkeys.push_back({{87,67},'+',1,13,3,6});
     monkeys.push_back({{95, 79, 92, 82, 60},'+',6,3,1,6});
     monkeys.push_back({{67, 97, 56},'*',-1,17,7,0});
     monkeys.push_back({{80, 68, 87, 94, 61, 59, 50, 68},'*',7,19,5,2});
     monkeys.push_back({{73, 51, 76, 59},'+',8,7,2,1});
     monkeys.push_back({{92},'+',5,11,3,0});
-    monkeys.push_back({{99, 76, 78, 76, 79, 90, 89},'+',7,5,4,5});
+    monkeys.push_back({{99, 76, 78, 76, 79, 90, 89},'+',7,5,4,5});*/
+    monkeys.push_back({{79,98},'*',19,23,2,3});
+    monkeys.push_back({{54, 65, 75, 74},'+',6,19,2,0});
+    monkeys.push_back({{79, 60, 97},'*',-1,13,1,3});
+    monkeys.push_back({{74},'+',3,17,0,1});
 
     for (int round=0;round<10000;round++){
         for (int i=0;i<monkeys.size();i++){
             Monkey&m=monkeys[i];
             m.inspAmt+=m.items.size();
             for (int j=0;j<m.items.size();j++){
-                BigInt worryLevel=m.items[j];
-                std::cout<<worryLevel<<std::endl;
+                factorNumber worryLevel=m.items[j];
+                //std::cout<<worryLevel<<std::endl;
                 if (m.operation=='+'){
                     if (m.operation_amt!=-1){
                         worryLevel+=m.operation_amt;
@@ -47,13 +132,9 @@ int main()
                 } else {
                     if (m.operation_amt!=-1){
                         worryLevel*=m.operation_amt;
-                    } else {
-                        worryLevel*=worryLevel;
                     }
                 }
-                //worryLevel/=3;
-                BigInt zero{"0"};
-                if (worryLevel%m.divisible==zero){
+                if (worryLevel%m.divisible==0){
                     Monkey&newMonkey=monkeys[m.trueThrow];
                     newMonkey.items.push_back(worryLevel);
                     m.items.erase(m.items.begin());
@@ -66,6 +147,13 @@ int main()
                 }
             }
         }
+        if (round==19||round==0||(round+1)%1000==0){
+            std::cout<<"Round "<<(round+1)<<"..."<<std::endl;
+            for (int i=0;i<monkeys.size();i++){
+                Monkey&m=monkeys[i];
+                std::cout<<"  Monkey "<<i<<": "<<m.inspAmt<<" inspected"<<std::endl;
+            }
+        }
     }
 
     std::sort(monkeys.begin(),monkeys.end(),[](Monkey&first,Monkey&second){return second.inspAmt<first.inspAmt;});
@@ -74,7 +162,7 @@ int main()
         std::cout<<"Monkey "<<i<<": "<<m.inspAmt<<" inspections"<<std::endl;
     }
 
-    std::cout<<(monkeys[0].inspAmt*monkeys[1].inspAmt)<<std::endl;
+    std::cout<<((long)monkeys[0].inspAmt*(long)monkeys[1].inspAmt)<<std::endl;
 
 	return 0;
 }
diff --git a/testInput b/testInput
new file mode 100644
index 0000000..c04eddb
--- /dev/null
+++ b/testInput
@@ -0,0 +1,27 @@
+Monkey 0:
+  Starting items: 79, 98
+  Operation: new = old * 19
+  Test: divisible by 23
+    If true: throw to monkey 2
+    If false: throw to monkey 3
+
+Monkey 1:
+  Starting items: 54, 65, 75, 74
+  Operation: new = old + 6
+  Test: divisible by 19
+    If true: throw to monkey 2
+    If false: throw to monkey 0
+
+Monkey 2:
+  Starting items: 79, 60, 97
+  Operation: new = old * old
+  Test: divisible by 13
+    If true: throw to monkey 1
+    If false: throw to monkey 3
+
+Monkey 3:
+  Starting items: 74
+  Operation: new = old + 3
+  Test: divisible by 17
+    If true: throw to monkey 0
+    If false: throw to monkey 1
\ No newline at end of file