//-----------------------------------------------------------------------
//	File:		prob.cc
//	Description:	Middle Earth math
//	Author:		Evan Golub (egolub@cs.umd.edu)
//-----------------------------------------------------------------------

#include <stdlib.h>
#include <iostream.h>
#include <assert.h>

#include <ctype.h>
#include <math.h>
#include <iomanip.h>

// Uncomment the following lines if using APCS classes
// #include "apvector.h"
// #include "apmatrix.h"
// #include "apstack.h"
// #include "apqueue.h"

#include "apstring.cpp"


//MY SOLUTION PART BEGINS HERE

int convertBaseToBase(int initBase, int newBase, int number) {
	int exp10;
	int expB;
	int positions;

	//convert from base initBase to base 10
	int base10 = 0;
	positions = (int)ceil(log10(number+1));
	for (int i=0; i<positions; i++) {
		exp10 = (int)pow(10,i);
		expB = (int)pow(initBase,i);
		base10 += expB * ((number/exp10)%10);
	}

	//convert from base 10 to base newBase
	int ans = 0;
	exp10 = 1;
	while (base10 >= newBase) {
		ans+=exp10*(base10%newBase);
		exp10*=10;
		base10/=newBase;
	}
	ans+=base10*exp10;

	return ans;
}


int baseMult(int base, int op1, int op2, char operation) {
int ans;

    int val1=convertBaseToBase(base, 10, op1);
    int val2=convertBaseToBase(base, 10, op2);
    switch (operation) {
        case '*': ans=convertBaseToBase(10, base, val1*val2); break;
        case '+': ans=convertBaseToBase(10, base, val1+val2); break;
    }
    return ans;
}


void buildMath(int base, 
                  int operand1, int operand2, char operation, 
                  int* steps, int& numSteps, int& result) {

    if (operation=='*') {
        numSteps=(int)ceil(log10(operand2+1));
	if (numSteps>1) {
            int tempOperand=operand2;
            for (int i=0; i<numSteps; i++) {
                steps[i] = baseMult(base, operand1, tempOperand%10, operation);
                tempOperand/=10;
            }
        }
        else {
            numSteps=0;
        }
    }
    if ((operation=='+')||(operation=='-')) {
        numSteps=0;
    }
    result = baseMult(base, operand1, operand2, operation);
}


//MY SOLUTION PART ENDS HERE

//-----------------------------------------------------------------------
//  verifyInput - make sure input is legal for base
//-----------------------------------------------------------------------

void verifyInput(int base, int num) {


	if (num >= 10000) {
		cout << "ERROR: number too large " << num << endl;
		return;
	}

	int n = num;
	while (n > 0) {
		if ((n % 10) >= base) {
			cout << "ERROR: illegal number " << num << endl;
			return;
		}
		n = n/10;
	}
}


//-----------------------------------------------------------------------
//  readIn - read input
//-----------------------------------------------------------------------

void readIn(istream& is, 
            char& race, int& operand1, int& operand2, char& operation) {
	is >> ws >> race 
	    >> ws >> operand1 
	    >> ws >> operand2 
	    >> ws >> operation;
}

//-----------------------------------------------------------------------
//  writeOut - write output
//-----------------------------------------------------------------------

void writeOut(ostream& os, 
              int operand1, int operand2, char operation, 
              int steps[100], int n, int result) {

	int i, WIDTH;
	
	WIDTH = (int) ceil(log10(result+1)) + 2;
	if ((i = (int) ceil(log10(operand1+1)) + 2) > WIDTH)
		WIDTH = i;
	if ((i = (int) ceil(log10(operand2+1)) + 2) > WIDTH)
		WIDTH = i;

	os << setw(WIDTH) << operand1 << endl;
	os << operation << setw(WIDTH-1) << operand2 << endl;
	if (n>1) {
		for (i=0; i<WIDTH; i++) {
			os << "-";
		}
		os << endl;
		for (i=0; i<n; i++) {
			os << setw(WIDTH-i) << steps[i] << endl;
		}
	}
	for (i=0; i<WIDTH; i++) {
		os << "=";
	}
	os << endl;
	os << setw(WIDTH) << result << endl;
}

//-----------------------------------------------------------------------
//  main
//-----------------------------------------------------------------------

int
main()
{
	char race;			// human elf dwarf wizard
	int  operand1;		// 1st number
	int  operand2;		// 2nd number
	char operation;		// + or *
	int  base;			// base for math

	// read & verify input 

	readIn(cin, race, operand1, operand2, operation);

	switch (tolower(race)) {
        	case 'h': base=10; break;//human
	        case 'e': base=8; break; //elf
		case 'd': base=5; break; //dwarf
		case 'w': base=2; break; //wizard
		default: 
			cout << "ERROR: illegal race " << race << endl; 
			return 0;
	}

	if ((operation != '*') && (operation != '+')) {
		cout << "ERROR: illegal operation " << operation << endl; 
		return 0;
	}

	verifyInput(base, operand1);
	verifyInput(base, operand2);

	// perform math

	int steps[100];		// intermediate results for multiply
	int numSteps;		// number of intermediate results
	int result;		// actual result

	buildMath(base, operand1, operand2, operation, 
		steps, numSteps, result);

	// display results 

	writeOut(cout, operand1, operand2, operation, 
		steps, numSteps, result);

	return 0;
}