#include "zxshady/bigint/bigint.hpp"     // with proper file path and link bigint.cpp

bigint a("1538901385913857893173895103987501387");     // big integer initialization with String
bigint b(std::string("-351901380593"));        // big integer initialization with String
bigint c(956486133);                                    // big integer intialization with Integer
bigint d = 129084091248;

// bigint e = "1209841092" // error the string constructor is explicit to prevent unnecesary conversions
// bigint f = std::string("12091204"); // same as above
std::string str = "hi 123";
bigint g(str.c_str() + 3,str.c_str() + str.size()); //range constructor constructs begining at "123"
bigint h(str.c_str()+3,3) // starts at str.c_str()+3 then reads next 3 characters

// bigint i = nullptr; // error usage of deleted constructor (bigint::bigint(nullptr)= delete)
bigint j{}; // fastest way to initialize to zero
bigint k; // fastest way to initialize to zero
//bigint l(); // silent error it is a function declaration
bigint m{0} // is slower than two above
bigint o{"0xDeAdBeEf"}; // 3735928559
bigint p("0B1101"); // 13
bigint q(static_cast<__int128>(1e30)); // extended integers

str = "ff";
bigint r(str.begin(),str.end(),bigint::base::hex)
str = "1111'1110'0001";
bigint s(str.begin(),str.end(),bigint::base::bin,'\'') // seperator
str = "0xff'ff'ff'ff";
bigint t(str.begin(),str.end(),'\'') // seperator
bigint u("0o70"); // octal

zxshady::bigint a= 12,b = 941830318,c{"10984019384143130598013958"};

if(0){
hell:
  *(int*)0; // suicide
}
c += 12; // same as c = c + 12; but it might be faster to use +=
c /= 5;
c -= bigint("0000983109813409810948109384"); // will ignore leading zeroes
c %= 2;
--c; // way faster than c -= 1
c--; // post-fix version is [[nodiscard]] might get warning or error
++c; // way faster than c += 1
c++;  // post-fix version is [[nodiscard]] might get warning or error
c/= 0; // throws std::invalid_arguement
c%= 0;// same as above;
if(!c && !a && b) goto hell;// operator bool to check for non-zero and operator! to check for zero
// it is faster than using c == 0 and b != 0
a = -b; // unary minus returns a copy and flips its sign;
a = +b; // DOES NOT DO abs(b) it just returns a copy...

1. bool is_even() const noexcept; // faster than a % 2 == 0
2. bool is_odd() const noexcept; // faster than a % 2 == 1
3. bool is_prime() const noexcept; // slow basic implementation :(
4. void flip_sign() noexcept; // flips the sign faster than a = -a
5. void set_positive() noexcept; // makes the number positive faster than a = abs(a)
6. void set_negative() noexcept; // makes the number negative faster than a = a >= 0 ? -a : a;
7. void set_sign(bool negative); noexcept // sets the sign
8. void reverse(); // reverses the number NOTE: slow function
9. void zero(); // sets the number to 0 faster than a = 0
10. bigint& half(); // halves the number way faster than a /= 2 returns *this for chaining effect
10. bigint& double_(); doubles the number way faster than a *= 2 returns *this for chaning
11. bool is_pow_of_10() const noexcept;
12. bool is_pow_of_2() const noexcept;
13. std::string to_string() const;
14. std::size_t digit_count() const noexcept;
15. std::size_t bit_count() const noexcept;
16. int compare(const bigint& that) const noexcept // a memcpy like function
// returns
// a number *< 0* if *this < that
// a *0* if *this == that    
// a number *> 0* if *this > that

17. int signless_compare(const bigint& that) // same as above but compares as if they were abs(*this).compare(abs(that));
// faster than using abs method
18. void swap(bigint& that) noexcept; 
19. bool signless_NAME(const bigint& that) // NAME could be lt,gt,lteq,gteq
// compares as abs values

    static bigint pow10(unsigned long long exponent); // gives bigint with [exponent] trailing zeroes
    static bigint rand(std::size_t digits = 1000); // random bigint [with default = 1000]

bigint value = 0xff;
std::cout << std::oct << value; // 377
std::cout << std::dec << std::showpos << value; // +255
std::cout << std::hex << std::showbase << std::showpos << value; // +0xff
std::cout << std::uppercase << value; // 0XFF

bigint x;
std::cin >> x; // enter a number
std::cout << x; // output it!

bigint abs(bigint x); // abs function
bigint fac(bigint x);// factorial function
bigint pow(bigint base,unsigned long long exponent);
bigint sqrt(const bigint& x);
bigint gcd(bigint a, bigint b); // greatest commmon denomator
bigint lcm(const bigint& a, const bigint& b);

unsigned long long log2(bigint x);
unsigned long long log10(const bigint& x);
unsigned long long log(const bigint& x, unsigned long long base);

std::ostream& operator<<(std::ostream& ostream, const bigint& bignum); // output operator
std::istream& operator>>(std::istream& istream, bigint& bignum); // input operator

using namespace zxshady::literals::bigint_literals; // or zxshady::bigint_literals;
auto val = "120948190380984093810948190348813409813571980709795748758798"_big;
pow(100_big,10000);

// to bring all of them at once use
using namespace zxshady::literals;

bigint a = 12;
if(a > 12) {
    cout << "a is greater than 12" << std::endl;
} else {
    cout << "a is smaller than 12" << std::endl;
}
// using yoda notation (yikes)
if(12 != a) {
    cout << "a is not equal to 12" << std::endl;
} else {
    cout << "a is equal to 12" << std::endl;        
}

bigint x = 21982014;
auto val = x.to<int>();// will throw std::range_error if cannot fit inside int;
x.set_negative();
// using unsigned types will just ignore the sign...
auto val = x.to<unsigned int>();// will throw std::range_error if cannot fit inside unsigned int;

// there is also bigint::non_throwing_to<Integral>() which returns a type of zxshady::result<Integeral,std::errc> and is noexcept
zxshady::result<int> val = x.non_throwing_to<int>();
if(val.ec == std::errc()){ // or use if(val) it has convversion to bool
  // can use val.res;
} else {
    if(val.ec == std::errc::result_out_of_range){
    // format harddrive
  }
}