#include <iostream>
#include <cctype>

const int MAXSIZE = 100;

struct BigNum{
   int digits[MAXSIZE];
   bool sign;
   int length;
};

void read_bignum(BigNum  & a);
void print_bignum(BigNum  a);
void init_bignum(BigNum & a);

int compare_bignum(BigNum a, BigNum b);
void copy_bignum(BigNum source, BigNum & dest);
void swap_bignum(BigNum & a, BigNum & b);

void operate_bignum(char op, BigNum a, BigNum b, BigNum & c) ;
void add_bignum(BigNum a, BigNum b, BigNum & c) ;
void sub_bignum(BigNum a, BigNum b, BigNum & c) ;
void mult_bignum(BigNum a, BigNum b, BigNum & c) ;
void div_bignum(BigNum a, BigNum b, BigNum & c) ;

int main () {
    BigNum a,b,c;

    BigNum nums[10];

    nums[0].sign = true;
    nums[0].length = 1;
    nums[0].digits[MAXSIZE-1] = 4;
    

    init_bignum(a);
    init_bignum(b);
    init_bignum(c);

    cout << "Enter a number, up to " << MAXSIZE << " digits ";
    read_bignum(a);

    cout << "Enter a number, up to " << MAXSIZE << " digits ";
    read_bignum(b);

    mult_bignum(a,b,c);
    print_bignum(a);
    cout << " x  ";
    print_bignum(b);
    cout << " =  ";
    print_bignum(c);
    cout << endl;

}

void read_sign(bool & sign){
    char ch;

    // skip blank space
    do  {
       cin.get(ch);
    } while (isspace(ch));

    // if we have a + it is positive
    // if we have a - it is negative
    // otherwise put it back in the input stream.

    switch(ch) {
       case '+' : sign = true;
                  break;
       case '-' : sign = false;
                  break;
       default:
                sign = true;
       		cin.unget();
    }
}

void read_digits(int dig[], int & size) {
     int tmpin[MAXSIZE];
     int i;
     char ch;

     cin.get(ch);
     i = 0;
     while (isdigit(ch) && (i < MAXSIZE)) {
        tmpin[i] = ch -'0';
        cin.get(ch);
        i++;
     }
     
 // if we have exceeded the size, put the last one back.
 // also put it back if it is not a digit.

     if ((i == MAXSIZE) || !isdigit(ch))  {
        cin.unget();
     }

     size = i;
     for(i=0; i < size; i++) {
        dig[i] = tmpin[size-(i+1)];
     }
}

void read_bignum(BigNum  & a){
   read_sign(a.sign);
   read_digits(a.digits, a.length);
}

void print_sign(bool sign) {
    if (!sign) {
       cout << "-";
    }
}

void print_digits(int dig[], int size) {
    int i;

    if(size == 0) {
       cout << 0;
    } else {
        for(i=size-1;i>=0;i--) {
           cout << dig[i];
        }
    }
}

void print_bignum(BigNum  a){
   print_sign(a.sign);
   print_digits(a.digits,a.length);
}

void init_bignum(BigNum & a){
   int i;

   a.sign = true;
   a.length = 0;
   for(i=0;i<MAXSIZE;i++) {
      a.digits[i] = 0;
   }
}


// return -1 if a is bigger
// return  0 if they are equal
// return  1 if b is bigger

int compare_bignum(BigNum a, BigNum b){
   // Homework 3.
   return(0);
}

void copy_bignum(BigNum source, BigNum & dest){
   // Homework 3.
}

void swap_bignum(BigNum & a, BigNum & b){
   BigNum tmp;
   int i;
   int hold;

   copy_bignum(a, tmp);
   copy_bignum(b,a);
   copy_bignum(tmp,b);
}


void operate_bignum(char op, BigNum a, BigNum b, BigNum & c) {
}

void add_bignum(BigNum a, BigNum b, BigNum & c) {
   // Homework 3
}

void sub_bignum(BigNum a, BigNum b, BigNum & c) {
   // Homework 3
}

bool decide_sign(bool one, bool two) {

     // if both signs are the same, the product is positive
     // if they are different, the product is negative

     if (one == two) {
        return(true);
     } else {
        return(false);
     }

     // could also be just
     // return(one == two);
}

void mult_bignum(BigNum a, BigNum b, BigNum & c) {
   int i, j;
   int carry;
   int prod;

   init_bignum(c);
   c.sign = decide_sign(a.sign, b.sign);

   // check to see if we have room for the product
   if (a.length+b.length < MAXSIZE) {
      c.length = a.length + b.length;

      for(i=0;i<a.length;i++) {
         carry = 0;
         for(j=0;j<b.length;j++) {
             prod = c.digits[i+j] + a.digits[i]*b.digits[j]+carry;
             c.digits[i+j] = prod % 10;
             carry = prod / 10;
         }
         c.digits[i+j] += carry;
      }
      if (carry == 0) {
          c.length --;
      }

   } else {
      cout << "Can't multiply these number " << endl;
      // what should we do here?
      //   A number of possiblities...
      //      1.  Just make the number all 0, and return an error
      //      2.  Do what we can, but no more (overflow).
   }


}

void div_bignum(BigNum a, BigNum b, BigNum & c) {
   // we will not do this one.
}