#include <iostream>
#include <cstdlib>
#define INTMAX  2147483647
//declare classes, functions
class Node;
class Number;
Node* MallocNode();
void CreateNode(Node*, int);
int ReadNode(Node*, int);
void WriteNode(Node*, int, int);
void AddtoNode(Node*, int, int);
Node* ReturnAddr(Node*, int);
int FindLength(Node*);
void Check(Node*);
void Check0(Node*);
Number sqrt(Number);


class Node {
private:
	char number;
	Node* ptr;
	friend Node* MallocNode();
	friend void CreateNode(Node*, int);
	friend int ReadNode(Node*, int);
	friend void WriteNode(Node*, int, int);
	friend void AddtoNode(Node*, int, int);
	friend Node* ReturnAddr(Node*, int);
	friend int FindLength(Node*);
	friend void Check(Node*);
	friend void Check0(Node*);
	friend Number;
	friend std::istream &operator>>(std::istream &, Number &);
	friend std::ostream &operator<<(std::ostream &, Number);
	friend Number sqrt(Number);
};

class Number {
public:
	void Free();
	bool operator<(const Number&);
	bool operator<(int);
	bool operator<(char *);
	bool operator>(const Number&);
	bool operator>(int);
	bool operator>(char *);
	friend std::istream &operator>>(std::istream &, Number &);
	friend std::ostream &operator<<(std::ostream &, Number);
	void operator=(const Number&);
	void operator=(int);
	void operator=(char *);
	bool operator==(const Number&);
	bool operator==(int);
	bool operator==(char *);
	bool operator!=(const Number&);
	bool operator!=(int);
	bool operator!=(char *);
	bool operator<=(const Number&);
	bool operator<=(int);
	bool operator<=(char *);
	bool operator>=(const Number&);
	bool operator>=(int);
	bool operator>=(char *);
	bool operator&&(const Number&);
	bool operator&&(int);
	bool operator&&(char *);
	bool operator||(const Number&);
	bool operator||(int);
	bool operator||(char *);
	Number operator+(const Number&);
	Number operator+(int);
	Number operator+(char *);
	void operator+=(const Number&);
	void operator+=(int);
	void operator+=(char *);
	Number operator++(int);//(*this)++
	Number& operator++();// ++(*this)
	Number operator-(const Number&);
	Number operator-(int);
	Number operator-(char *);
	void operator-=(const Number&);
	void operator-=(int);
	void operator-=(char *);
	Number operator--(int);
	Number& operator--();
	Number operator*(const Number&);
	Number operator*(int);
	Number operator*(char *);
	void operator*=(const Number&);
	void operator*=(int);
	void operator*=(char *);
	Number operator/(const Number&);
	Number operator/(int);
	Number operator/(char *);
	void operator/=(const Number&);
	void operator/=(int);
	void operator/=(char *);
	Number operator%(const Number&);
	Number operator%(int);
	Number operator%(char *);
	void operator%=(const Number&);
	void operator%=(int);
	void operator%=(char *);
	int Length();
	friend Number sqrt(Number);
	operator char();
	operator int();
	operator long long int();
	operator double();
	operator float();
private:
	Node* Head = NULL;
	char biggerthan0 = 1;
	// biggerthan0 == 0 -> <0
	// biggerthan0 == 1 -> >= 0
	// biggerthan0 == 2 -> Unlumited
	void Reverse(int);
	void Free(Node*);
};



//Func about Node
Node* ReturnAddr(Node* input, int element) {
	for (int i = 0; i < element; i++) {
		input = input->ptr;
	}
	return input;
};
int FindLength(Node* input) {
	int count = 0;
	while (input->ptr != NULL) {
		count++;
		input = input->ptr;
	}
	return count;
};
void Check(Node* input) {//check if there's a number that is bigger than 9
	int length = FindLength(input);
	int temp;
	for (int i = 0; i <= length; i++) {
		temp = ReadNode(input, 0);
		if (temp >= 10) {
			if (i == length) {
				CreateNode(ReturnAddr(input, 0), 1);
			}
			WriteNode(input, 0, temp % 10);
			AddtoNode(input, 1, temp / 10);
		}
		input = input->ptr;
	}
};
void Check0(Node* input) {
	Node* tempN;
	int MaxLength = FindLength(input);
	for (int i = MaxLength; i > 0; i--) {
		if (ReadNode(input, i) == 0) {
			tempN = ReturnAddr(input, i - 1);
			free(tempN->ptr);
			tempN->ptr = NULL;
		}
		else if (ReadNode(input, i) != 0) {
			break;
		}
	}
};
Node* MallocNode() {
	Node* ptr = (Node*)malloc(sizeof(Node));
	ptr->number = 0;
	ptr->ptr = NULL;
	return ptr;
};
void CreateNode(Node* input, int quantity) {
	for (int i = 0; i < quantity; i++) {
		input->ptr = MallocNode();
		input = input->ptr;
	}
};
int ReadNode(Node* input, int element) {
	for (int i = 0; i < element; i++) {
		input = input->ptr;
	}
	return (int)(input->number);
};
void WriteNode(Node* input, int element, int value) {
	for (int i = 0; i < element; i++) {
		input = input->ptr;
	}
	input->number = value;
};
void AddtoNode(Node* input, int element, int value) {
	for (int i = 0; i < element; i++) {
		input = input->ptr;
	}
	input->number += value;
};



//Func about Number
Number sqrt(Number input) {
	int Length, count;
	Node *NodeTemp;
	Number result, temp, temp2, temp3, number2;
	result = 0;
	number2 = 2;
	Length = input.Length();
	if (Length == 0) {
		result = 1;
		for (; result < 4; ++result) {
			temp = result * result;
			if (temp == input) {
				return result;
			}
			if (temp > input) {
				result = -1;
				return result;
			}
		}
	}
	if (Length == 1) {
		result = 3;
		for (; result < 10; ++result) {
			temp = result * result;
			if (temp == input) {
				return result;
			}
			if (temp > input) {
				result = -1;
				return result;
			}
		}
	}
	//Length > 1
	if (Length % 2 == 1) {//4 6 8...
		temp.Head = ReturnAddr(input.Head, Length - 1);
		for (int i = 1; i <= Length/2 + 1; i++) {
			for (count = 0; count <= 10; count++) {
				temp3 = result * number2;
				temp3 = temp3 + count;
				temp3 = temp3 * count;
				if (i > 1) {
					if (temp3 == temp2) {
						break;
					}
					if (temp3 > temp2) {
						count -= 1;
						break;
					}
				}
				else {
					if (temp3 == temp) {
						break;
					}
					if (temp3 > temp) {
						count -= 1;
						break;
					}
				}
			}
			temp3 = result * number2;
			temp3 = temp3 + count;
			temp3 = temp3 * count;
			if (i < Length/2 + 1) {
				if (i > 1) {
					temp2 -= temp3;
				}
				else {
					temp2 = temp - temp3;
				}
				if (i == 1 && temp2 == 0) {
					temp2.Head->number = ReadNode(input.Head, Length - i*2);
					NodeTemp = temp2.Head;
					temp2.Head = MallocNode();
					temp2.Head->ptr = NodeTemp;
					temp2.Head->number = ReadNode(input.Head, Length - i*2 - 1);
				}
				else {
					NodeTemp = temp2.Head;
					temp2.Head = MallocNode();
					temp2.Head->ptr = NodeTemp;
					temp2.Head->number = ReadNode(input.Head, Length - i*2);
					NodeTemp = temp2.Head;
					temp2.Head = MallocNode();
					temp2.Head->ptr = NodeTemp;
					temp2.Head->number = ReadNode(input.Head, Length - i*2 - 1);
				}
				if (!(i == 1 && temp2 == 0)) {
					result.Head->number = count;
					NodeTemp = result.Head;
					result.Head = MallocNode();
					result.Head->ptr = NodeTemp;
				}
				else if (i == 1 && temp2 > 0) {
					result.Head->number = count;
				}
			}
			else {
				result.Head->number = count;
				if (temp3 < temp2) {
					result = -1;
					return result;
				}
				temp3.Free();
				temp2.Free();
			}
		}
	}
	else {//3 5 7...
		int count2;
		result = 0;
		count2 = ReadNode(input.Head, Length);
		for (count = 0; count <= 4; count++) {
			temp = count * count;
			if (temp > count2) {
				count -= 1;
				break;
			}
			if (temp == count2) {
				break;
			}
		}
		if (count > 0) {
			result.Head->number = count;
			NodeTemp = result.Head;
			result.Head = MallocNode();
			result.Head->ptr = NodeTemp;
		}
		temp = count2 - count * count;
		if (temp > 0) {
			NodeTemp = temp.Head;
			temp.Head = MallocNode();
			temp.Head->ptr = NodeTemp;
		}
		temp.Head->number = ReadNode(input.Head, Length - 1);
		NodeTemp = temp.Head;
		temp.Head = MallocNode();
		temp.Head->ptr = NodeTemp;
		temp.Head->number = ReadNode(input.Head, Length - 2);
		for (int i = 1; i <= Length/2; i++) {
			Check0(temp.Head);
			for (count = 0; count <= 10; count++) {
				temp3 = result * number2;
				temp3 = temp3 + count;
				temp3 = temp3 * count;
				if (temp3 == temp) {
					break;
				}
				if (temp3 > temp) {
					count -= 1;
					break;
				}
			}
			temp3 = result * number2;
			temp3 = temp3 + count;
			temp3 = temp3 * count;
			if (i < Length/2) {
				result.Head->number = count;
				NodeTemp = result.Head;
				result.Head = MallocNode();
				result.Head->ptr = NodeTemp;

				temp -= temp3;
				if (temp > 0) {
					NodeTemp = temp.Head;
					temp.Head = MallocNode();
					temp.Head->ptr = NodeTemp;
				}
				temp.Head->number = ReadNode(input.Head, Length - i*2 - 1);
				NodeTemp = temp.Head;
				temp.Head = MallocNode();
				temp.Head->ptr = NodeTemp;
				temp.Head->number = ReadNode(input.Head, Length - i*2 - 2);
			}
			else {
				result.Head->number = count;
				if (temp3 < temp) {
					result = -1;
				}
			}
		}
		temp.Free();
		temp3.Free();
		number2.Free();
	}
	return result;
}
void Number::Free() {
	Free(Head);
};
bool Number::operator<(const Number& input) {
	Number temp;
	temp = input;
	Node* A = this->Head;
	Node* B = input.Head;
	if (A->ptr == NULL && B->ptr == NULL && A->number == 0 && B->number == 0) {
		this->biggerthan0 = 1;
		temp.biggerthan0 = 1;
		return 0;
	}
	if (this->biggerthan0 == 1 && input.biggerthan0 == 0) {
		return 0;
	}
	if (this->biggerthan0 == 0 && input.biggerthan0 == 1) {
		return 1;
	}
	int positive = 1;
	if (this->biggerthan0 == 0 && input.biggerthan0 == 0) {
		positive = 0;
	}
	int a = FindLength(A);
	int b = FindLength(B);
	if (a < b) {
		if (positive == 1)
			return 1;
		else
			return 0;
	}
	if (a > b) {
		if (positive == 1)
			return 0;
		else
			return 1;
	}
	for (int i = a; i >= 0; i--) {
		a = ReadNode(A, i);
		b = ReadNode(B, i);
		if (a < b) {
			if (positive == 1)
				return 1;
			else
				return 0;
		}
		if (a > b) {
			if (positive == 1)
				return 0;
			else
				return 1;
		}
	}
	return 0;
};
bool Number::operator<(int input) {
	Number temp;
	temp = input;
	return *this < temp;
};
bool Number::operator<(char input[]) {
	Number temp;
	temp = input;
	return *this < temp;
};
bool Number::operator>(const Number& input) {
	Number temp;
	temp = input;
	return temp < *this;
};
bool Number::operator>(int input) {
	Number temp;
	temp = input;
	return temp < *this;
};
bool Number::operator>(char input[]) {
	Number temp;
	temp = input;
	return temp < *this;
};
std::istream &operator>>(std::istream &a, Number &b) {
	b.Free();
	b.Head = MallocNode();
	Node* ptr = b.Head;
	int length = 0;
	char InputChar;
	InputChar = a.get();
	if (InputChar == '\n' || InputChar == ' ') {
		InputChar = a.get();
	}
	while (InputChar != '\n' && InputChar != ' ') {
		if (InputChar == '-') {
			b.biggerthan0 = 0;
			InputChar = a.get();
		}
		ptr->number = InputChar - '0';
		InputChar = a.get();
		if (InputChar != '\n' && InputChar != ' ') {
			CreateNode(ptr, 1);
			ptr = ptr->ptr;
			length++;
		}
	}
	b.Reverse(length);
	return a;
};
std::ostream &operator<<(std::ostream &a, Number b) {
	if (b.biggerthan0 == 2) {
		a << "inf";
		return a;
	}
	if (b.biggerthan0 == 0) {
		a << "-";
	}
	if (b.Head->ptr == NULL) {
		a << (int)(b.Head->number);
	}
	else {
		Node *ptr;
		ptr = b.Head;
		int length = FindLength(ptr);
		b.Reverse(length);
		while (ptr != NULL) {
			a << (int)(ptr->number);
			ptr = ptr->ptr;
		}
		b.Reverse(length);
	}
	return a;
};

void Number::operator=(const Number& b) {
	Free(this->Head);
	this->Head = b.Head;
	this->biggerthan0 = b.biggerthan0;
};
void Number::operator=(int b) {
	Free(this->Head);
	this->Head = MallocNode();
	Node* ptr = this->Head;
	if (b < 0) {
		this->biggerthan0 = 0;
		b = -b;
	}
	while (b > 0) {
		ptr->number = b % 10;
		b /= 10;
		if (b > 0) {
			CreateNode(ptr, 1);
			ptr = ptr->ptr;
		}
	}
};
void Number::operator=(char b[]) {
	size_t length = strlen(b);
	Free(this->Head);
	this->Head = MallocNode();
	Node* ptr = this->Head;
	while (length > 0) {
		WriteNode(ptr, 0, b[length - 1] - '0');
		length--;
		if (length > 0 && b[length - 1] != '-') {
			CreateNode(ptr, 1);
			ptr = ptr->ptr;
		}
		if (b[length - 1] == '-') {
			this->biggerthan0 = 0;
			break;
		}
	}
};
bool Number::operator==(const Number& b) {
	Number temp;
	temp = b;
	Node* A, *B;
	A = this->Head;
	B = temp.Head;
	unsigned int lengthA, lengthB;
	lengthA = FindLength(A);
	lengthB = FindLength(B);
	if (lengthA != lengthB)
		return 0;
	if (*this > temp || temp > *this) {
		return 0;
	}
	for (unsigned int i = 0; i <= lengthA; i++) {
		if (A->number != B->number) {
			return 0;
		}
		A = A->ptr;
		B = B->ptr;
	}
	return 1;
};
bool Number::operator==(int b) {
	Number temp;
	temp = b;
	return *this == temp;
};
bool Number::operator==(char b[]) {
	Number temp;
	temp = b;
	return *this == temp;
};
bool Number::operator!=(const Number& b) {
	return !(*this == b);
};
bool Number::operator!=(int b) {
	return !(*this == b);
};
bool Number::operator!=(char b[]) {
	return !(*this == b);
};
bool Number::operator<=(const Number& b) {
	return !(*this > b);
};
bool Number::operator<=(int b) {
	Number temp;
	temp = b;
	return !(*this > temp);
};
bool Number::operator<=(char b[]) {
	Number temp;
	temp = b;
	return !(*this > temp);
};
bool Number::operator>=(const Number& b) {
	return !(*this < b);
};
bool Number::operator>=(int b) {
	Number temp;
	temp = b;
	return !(*this < temp);
};
bool Number::operator>=(char b[]) {
	Number temp;
	temp = b;
	return !(*this < temp);
};
bool Number::operator&&(const Number& b) {
	Number temp;
	temp = b;
	if (*this != 0 && temp != 0) {
		return true;
	}
	return false;
};
bool Number::operator&&(int b) {
	Number temp;
	temp = b;
	return *this && temp;
};
bool Number::operator&&(char b[]) {
	Number temp;
	temp = b;
	return *this && temp;
};
bool Number::operator||(const Number& b) {
	Number temp;
	temp = b;
	if (*this != 0 || temp != 0) {
		return true;
	}
	return false;
};
bool Number::operator||(int b) {
	Number temp;
	temp = b;
	return *this && temp;
};
bool Number::operator||(char b[]) {
	Number temp;
	temp = b;
	return *this && temp;
};
Number Number::operator+(const Number& b) {
	Number result, temp;
	temp = b;
	if (this->biggerthan0 == 2 || b.biggerthan0 == 2) {
		result.Head = NULL;
		result.biggerthan0 = 2;
		return result;
	}
	if (*this >= 0 && temp >= 0) {
		Node *A = this->Head;
		Node *B = b.Head;
		result.Head = MallocNode();
		Node* C = result.Head;
		Node* temp = C;
		int ALength = FindLength(A);
		int BLength = FindLength(B);
		int MaxLength, tempA, tempB;
		if (BLength > ALength) {
			MaxLength = BLength;
		}
		else {
			MaxLength = ALength;
		}
		CreateNode(C, MaxLength);
		for (int i = 0; i <= MaxLength; i++) {
			if (i > ALength) {
				tempA = 0;
			}
			else {
				tempA = ReadNode(A, i);
			}
			if (i > BLength) {
				tempB = 0;
			}
			else {
				tempB = ReadNode(B, i);
			}
			WriteNode(temp, 0, tempA + tempB);
			temp = temp->ptr;
		}
		Check(C);
	}
	else if (*this >= 0 && temp < 0) {
		temp.biggerthan0 = 1;
		result = *this - temp;
		temp.biggerthan0 = 0;

	}
	else if (*this < 0 && temp >= 0) {
		this->biggerthan0 = 1;
		result = temp - *this;
		this->biggerthan0 = 0;
	}
	else if (*this < 0 && temp < 0) {
		this->biggerthan0 = 1;
		temp.biggerthan0 = 1;
		result = *this + temp;
		result.biggerthan0 = 0;
	}
	return result;
};
Number Number::operator+(int b) {
	Number A;
	A = b;
	return *this + A;
};
Number Number::operator+(char b[]) {
	Number A;
	A = b;
	return *this + A;
};
void Number::operator+=(const Number& b) {
	*this = *this + b;
};
void Number::operator+=(int b) {
	*this = *this + b;
};
void Number::operator+=(char b[]) {
	*this = *this + b;
};
Number Number::operator++(int) {
	Number temp;
	temp = *this + 0;
	*this += 1;
	return temp;
};
Number& Number::operator++() {
	*this += 1;
	return *this;
};
Number Number::operator-(const Number& b) {
	Number result, temp;
	temp = b;
	if (this->biggerthan0 == 2 || b.biggerthan0 == 2) {
		result.Head = NULL;
		result.biggerthan0 = 2;
		return result;
	}
	if (*this >= 0 && temp >= 0) {
		Node *A = this->Head;
		Node *B = b.Head;
		result.Head = MallocNode();
		Node* C = result.Head;
		int ALength = FindLength(A);
		int BLength = FindLength(B);
		int MaxLength, temp, tempA, tempB;
		Node* tempN;
		if (BLength > ALength) {
			MaxLength = BLength;
		}
		else {
			MaxLength = ALength;
		}
		CreateNode(C, MaxLength);
		if (*this < b) {
			tempN = B;
			B = A;
			A = tempN;
			result.biggerthan0 = 0;
			temp = ALength;
			ALength = BLength;
			BLength = temp;
		}
		for (int i = 0; i <= MaxLength; i++) {
			if (i > ALength) {
				tempA = 0;
			}
			else {
				tempA = ReadNode(A, i);
			}
			if (i > BLength) {
				tempB = 0;
			}
			else {
				tempB = ReadNode(B, i);
			}
			AddtoNode(C, i, tempA - tempB);
		}
		for (int i = 0; i < MaxLength; i++) {
			temp = ReadNode(C, i);
			if (temp < 0) {
				WriteNode(C, i, temp + 10);
				AddtoNode(C, i + 1, -1);
			}
		}
		Check0(C);
	}
	else if (*this >= 0 && temp < 0) {
		temp.biggerthan0 = 1;
		result = *this + temp;
		temp.biggerthan0 = 0;
	}
	else if (*this < 0 && temp >= 0) {
		temp.biggerthan0 = 0;
		result = *this + temp;
		temp.biggerthan0 = 1;
	}
	else if (*this < 0 && temp < 0) {
		temp.biggerthan0 = 1;
		result = temp + *this;
		temp.biggerthan0 = 0;
	}
	return result;
};
Number Number::operator-(int b) {
	Number A;
	A = b;
	return *this - A;
};
Number Number::operator-(char b[]) {
	Number A;
	A = b;
	return *this - A;
};
void Number::operator-=(const Number& b) {
	*this = *this - b;
};
void Number::operator-=(int b) {
	*this = *this - b;
};
void Number::operator-=(char b[]) {
	*this = *this - b;
};
Number Number::operator--(int) {
	Number temp;
	temp = *this - 0;
	*this -= 1;
	return temp;
};
Number& Number::operator--() {
	*this -= 1;
	return *this;
};
Number Number::operator*(const Number& b) {
	Number temp, result;
	temp = b;
	if (temp == 0 || *this == 0) {
		result.Head = MallocNode();
		result.Head->number = 0;
		result.Head->ptr = NULL;
		return result;
	}
	if (this->biggerthan0 == 2 || b.biggerthan0 == 2) {
		result.Head = NULL;
		result.biggerthan0 = 2;
		return result;
	}
	Node *A = this->Head;
	Node *B = b.Head;
	result.Head = MallocNode();
	Node *C = result.Head;
	Node *tempI, *tempAJ, *tempBI, *tempIJ;
	int ALength, BLength, IntTemp;
	ALength = FindLength(A);
	BLength = FindLength(B);
	CreateNode(C, ALength + BLength);
	tempI = C;
	tempBI = B;
	for (int i = 0; i <= BLength; i++) {
		tempIJ = tempI;
		tempAJ = A;
		for (int j = 0; j <= ALength && tempBI->number > 0; j++) {
			IntTemp = tempAJ->number * tempBI->number;
			if (IntTemp >= 10) {
				if (tempIJ->ptr == NULL) {
					tempIJ->ptr = MallocNode();
				}
				tempIJ->number += IntTemp % 10;
				tempIJ->ptr->number += IntTemp / 10;
			}
			else {
				tempIJ->number += IntTemp;
			}
			if (tempIJ->number >= 10) {
				if (tempIJ->ptr == NULL) {
					tempIJ->ptr = MallocNode();
				}
				tempIJ->ptr->number += tempIJ->number / 10;
				tempIJ->number %= 10;
			}
			tempIJ = tempIJ->ptr;
			tempAJ = tempAJ->ptr;
		}
		tempBI = tempBI->ptr;
		tempI = tempI->ptr;
	}
	if ((*this < 0 && !(temp < 0)) || (!(*this < 0) && temp < 0)) {
		result.biggerthan0 = 0;
	}
	return result;
};
Number Number::operator*(int b) {
	Number temp;
	temp = b;
	return *this * temp;
};
Number Number::operator*(char b[]) {
	Number temp;
	temp = b;
	return *this * temp;
};
void Number::operator*=(const Number& b) {
	Number temp;
	temp = b;
	*this = *this * temp;
};
void Number::operator*=(int b) {
	*this = *this * b;
};
void Number::operator*=(char b[]) {
	*this = *this * b;
};
Number Number::operator/(const Number& b) {
	Number result, temp, temp2, j, A, B;
	Node *NodeTemp;
	int ALength, BLength, Difference;
	A = *this;
	B = b;
	result = 0;
	if (A.biggerthan0 == 2 || B == 0) {
		result.biggerthan0 = 2;
		return result;
	}
	else if (A.biggerthan0 == 0 && B.biggerthan0 == 0) {
		A.biggerthan0 = 1;
		B.biggerthan0 = 1;
	}
	else if ((A.biggerthan0 == 1 && B.biggerthan0 == 0) || (A.biggerthan0 == 0 && B.biggerthan0 == 1)) {
		A.biggerthan0 = 1;
		B.biggerthan0 = 1;
		result.biggerthan0 = 0;
	}
	else if (A < B || A == 0 || B.biggerthan0 == 2) {
		return result;
	}

	ALength = A.Length();
	BLength = B.Length();
	Difference = ALength - BLength;
	temp.Head = ReturnAddr(A.Head, Difference);
	for (int i = 0; i <= Difference; i++) {
		for (j = 1; j <= 10; j++) {
            if (i == 0 && j * B > temp) {
                j = j - 1;
                result.Head->number = j;
                temp2 = temp - j * B;
                break;
            }
			else if (i > 0 && j * B > temp2) {
                j = j - 1;
                result.Head->number = j;
                temp2 = temp2 - j * B;
                break;
            }
		}
		if (i < Difference) {
			if (temp2 > 0) {
				NodeTemp = temp2.Head;
				temp2.Head = MallocNode();
				temp2.Head->ptr = NodeTemp;
			}
			temp2.Head->number = ReadNode(A.Head,Difference - i - 1);
			if (!(i == 0 && j == 0)) {
				NodeTemp = result.Head;
				result.Head = MallocNode();
				result.Head->ptr = NodeTemp;
			}
		}
	}
	temp2.Free();
	j.Free();
	return result;
};
Number Number::operator/(int b) {
	Number A;
	A = b;
	return *this / A;
};
Number Number::operator/(char b[]) {
	Number A;
	A = b;
	return *this / A;
};
void Number::operator/=(const Number& b) {
	*this = *this / b;
};
void Number::operator/=(int b) {
	*this = *this / b;
};
void Number::operator/=(char b[]) {
	*this = *this / b;
};
Number Number::operator%(const Number& b) {
	Number result, temp, temp2, j, A, B;
	Node *NodeTemp;
	int ALength, BLength, Difference;
	A = *this;
	B = b;
	result = 0;
	if (A.biggerthan0 == 2 || B == 0) {
		result.biggerthan0 = 2;
		return result;
	}
	else if (A.biggerthan0 == 0 && B.biggerthan0 == 0) {
		A.biggerthan0 = 1;
		B.biggerthan0 = 1;
		result.biggerthan0 = 0;
	}
	else if (A.biggerthan0 == 1 && B.biggerthan0 == 0) {
		B.biggerthan0 = 1;
	}
	else if (A.biggerthan0 == 0 && B.biggerthan0 == 1) {
		A.biggerthan0 = 1;
		result.biggerthan0 = 0;
	}
	else if (A < B) {
		temp2 = A + 0;
		result.Head = temp2.Head;
		return result;
	}

	ALength = A.Length();
	BLength = B.Length();
	Difference = ALength - BLength;
	temp.Head = ReturnAddr(A.Head, Difference);
	for (int i = 0; i <= Difference; i++) {
		for (j = 1; j <= 10; j++) {
            if (i == 0 && j * B > temp) {
                j = j - 1;
                result.Head->number = j;
                temp2 = temp - j * B;
                break;
            }
			else if (i > 0 && j * B > temp2) {
                j = j - 1;
                result.Head->number = j;
                temp2 = temp2 - j * B;
                break;
            }
		}
		if (i < Difference) {
			if (temp2 > 0) {
				NodeTemp = temp2.Head;
				temp2.Head = MallocNode();
				temp2.Head->ptr = NodeTemp;
			}
			temp2.Head->number = ReadNode(A.Head,Difference - i - 1);
			if (!(i == 0 && j == 0)) {
				NodeTemp = result.Head;
				result.Head = MallocNode();
				result.Head->ptr = NodeTemp;
			}
		}
		else {
			result.Head = temp2.Head;
		}
	}
	temp2.Free();
	j.Free();
	return result;
};
Number Number::operator%(int b) {
	Number temp;
	temp = b;
	return *this % temp;
};
Number Number::operator%(char b[]) {
	Number temp;
	temp = b;
	return *this % temp;
};
void Number::operator%=(const Number& b) {
	*this = *this % b;
};
void Number::operator%=(int b) {
	Number temp;
	temp = b;
	*this = *this % temp;
};
void Number::operator%=(char b[]) {
	Number temp;
	temp = b;
	*this = *this % temp;
};
void Number::Reverse(int length) {
	int j = 0;
	char temp;
	Node *input = Head;
	for (int i = length; i > length / 2; i--, j++) {
		temp = ReadNode(input, i);
		WriteNode(input, i, ReadNode(input, j));
		WriteNode(input, j, temp);
	}
};
void Number::Free(Node* input) {
	Node* temp;
	while (input != NULL) {
		temp = input->ptr;
		free(input);
		input = temp;
	}
};
int Number::Length() {
	return FindLength(Head);
}
Number::operator int() {
	Number b;
	b.Head = Head;
	if (b > INTMAX || b < -INTMAX) {
		return 0;
	}
	Node* ptr = b.Head;
	int result = 0;
	int MulBy10 = 1;
	result += ptr->number;
	ptr = ptr->ptr;
	while (ptr != NULL) {
		result += ptr->number * 10 * MulBy10;
		MulBy10 *= 10;
		ptr = ptr->ptr;
	}
	if (biggerthan0 == 0) {
		result *= -1;
	}
	return result;
}
Number::operator long long int() {
	Number b, LongLongIntMax;
	b.Head = Head;
	LongLongIntMax = "9223372036854775807";

	if (b > LongLongIntMax || b < LongLongIntMax * -1) {
		return 0;
	}
	Node *ptr = Head;
	long long int result, MulBy10;
	MulBy10 = 1;
	result = 0;
	result += ptr->number;
	ptr = ptr->ptr;
	while (ptr != NULL) {
		result += ptr->number * 10 * MulBy10;
		MulBy10 *= 10;
		ptr = ptr->ptr;
	}
	if (biggerthan0 == 0) {
		result *= -1;
	}
	return result;
}
Number::operator char() {
	Number b;
	b.Head = Head;
	int temp;
	temp = b;
	if (b >= 256) {
		return 0;
	}else {
		return temp;
	}
}
Number::operator double() {
	Number b, max;
	b.Head = Head;
	max = 1;
	for (int i = 0; i < 53; i++) {
		max *= 2;
	}
	if (b >= max || b < max * -1) {
		return 0;
	}
	Node *ptr = Head;
	double result, MulBy10;
	MulBy10 = 1;
	result = 0;
	result += ptr->number;
	ptr = ptr->ptr;
	while (ptr != NULL) {
		result += ptr->number * 10 * MulBy10;
		MulBy10 *= 10;
		ptr = ptr->ptr;
	}
	if (biggerthan0 == 0) {
		result *= -1;
	}
	return result;
}
Number::operator float() {
	Number b;
	b.Head = Head;
	int result;
	result = b;
	return (float)b;
}