Enhance your superint calculator.

(1) Add to your superint class the ability to handle negatives correctly. There are
    four places that need to take them into account: the operators, comparisons,
    input, and output.

(2) Add to your superint class the following operations

      superint / int

      superint % int

      superint / superint

      superint % superint

      superint ^ int

      superint ^ superint

    The only rational way to do a division automatically calculates modulo along the way,
    so you should write one master method a.divmod(b, c) which sets a to the result of
    a / b, and c to the result of a % b. Use that to create the / and % operators.

    ^ represents to-the-power-of. The ^ operator does exist in C++, so you can define it
    to calculate to-the-power-of, but that isn't what it is used for in C++. So beware,
    we would expect to-the-power-of to make higher priority than * and /, but it actually
    has very low priority.

(3) Also add these methods

      superint powmod(const superint &, const superint &)

          so that a.powmod(b, c) sets a to (a ^ b) % c.
          This is not as trivial as it looks. You can not just do a ^ operation and then
          do a % operation to the result. With superints, a ^ b could produce a number
          with trillions of digits that would be impossible to deal with. There is an
          easy way to do it, but unless you have studied number theory, you will have to
          pay attention when I tell you the method in class.

      superint random(int a, int b)

          pick a random number between a and b (inclusive) and return a random number
          with exactly that many digits. No leading zeros.

      static superint gcd(superint, superint)

          a = gcd(b, c) sets a to the greatest common divisor of b and c. Euclid's
          gcd algorithm is easy:

          gcd(a, b)
          { temporary variables x and t
            make a be positive (just change its sign to +)
            make b be positive
            while (b != 0)
            { t = a;
              a = b;
              t.divmod(b, x);
              b = x; }
            make a be positive
            return a; }
      
(4) Add the /, %, and ^ operators to your calculator

    Add a "powmod" operator to your calculator. It pops three things from the stack, 
    calculates (a ^ b) % c, and pushes the result back, so

          17 2 20 100 powmod should result in the stack containing just 17 and 576.
          The 17 is untouched, it is not one of the three operands. 2 ^ 20 is 1048576.

    Add a "random" operator to your calculator. It pops two things from the stack
    and uses their intval methods to generate a random number in the given size range.
    That number should be pushed onto the stack, so

          20 20 random could result in the stack containing 28341029620968421674
          (where the "28341029620968421674" could be replaced by any other 20 digit number)

    Add a "gcd" operator to your calculator,it pops two numbers and pushes their gcd

          999 888 777 51288 40128 gcd results in 999 888 777 24 being on the stack.

(4) Test everything thoroughly.