#include <stdio.h>

#define SIZE 4

int read_number();
void add_numbers();
void output_number();
void number2modular();
char skip_blanks();

main()
{
	/* Numbers are stored modulo 2*10^{SIZE}.
	 * Negative numbers are in the range 10^{SIZE}+1 to 2*10^{SIZE}-1.
	 * Positive numbers are in the range 0 to 10^{SIZE}-1.
	 * All the operations are done modulo 2*10^{SIZE}.
	 */
	char number1[SIZE+1]; /* First number */
	char number2[SIZE+1]; /* Second number */
	char number3[SIZE+1]; /* Stores the sum */

	/* Read first number */
	if (read_number(number1) == 0) /* error */
		return;
	output_number(number1);
	/* Read second number */
	if (read_number(number2) == 0) /* error */
		return;
	output_number(number2);
	
	/* Add numbers */
	add_numbers(number1, number2, number3);

	/* Output the result */
	output_number(number3);
}


/* Reads a number with up to SIZE many digits.
 * Stores the number modulo 2*10^{SIZE} with least
 * significant digit first. Returns error if number
 * has more than SIZE digits.
 */
int read_number(char number[])
{
	char symbol; /* Stores current input symbol */
	char temp[SIZE]; /* temporary storage for numbers */
	int size; /* stores the number of digits in input */

	printf("Input a number of at most %d digits: ", SIZE);

	symbol = skip_blanks(); /* Read the first non-white space symbol */
	if (symbol == '-') { /* negative number */
		number[SIZE] = 1;
		symbol = getchar(); /* read the first digit */
	}
	else /* positive number */
		number[SIZE] = 0;

	for (size = 0; 1; size++) {
		if ((symbol < '0') || (symbol > '9')) /* not a digit */
			break;
		if (size == SIZE) { /* input too large */
			printf("Input too large: number should be at most %d digits\n", SIZE);
			return 0;
		}
		temp[size] = symbol - '0';
		symbol = getchar(); /* read next symbol */
	}

	/* Store number in reverse order ,leaving the sign in place */
	int i;

	for (i = 0; i < size; i++)
		number[i] = temp[size-1-i];
	for (i = size; i < SIZE; i++)
		number[i] = 0;
	
	/* Convert to modular representation */
	number2modular(number);

	return 1;
} /* end of read_number() */


/* Converts the given number to its representation modulo 2*10^{SIZE} */
void number2modular(char number[])
{
	int i;

	if (number[SIZE] == 0) /* positive number */
		return;
	
	/* Subtract from 2*10^{SIZE} */
	for (i = 0; number[i] == 0; i++); /* skip zeros */

	if (i == SIZE) { /* number is -0 */
		number[SIZE] = 0; /* remove the -ve sign */
		return;
	}

	/* First non-zero digit, subtract from 10 */
	number[i] = 10 - number[i];

	/* Subtract remaining digits from 9 */
	for (i++; i < SIZE; i++)
		number[i] = 9 - number[i];

	return;
} /* end of number2modular() */


/* Adds the two numbers modulo 2*10^{SIZE} */
void add_numbers(char num1[], char num2[], char num3[])
{
	int carry; /* Stores the carry value */
	int i;

	for (i = 0, carry = 0; i <= SIZE; i++) {
		num3[i] = num1[i] + num2[i] + carry;
		if (num3[i] > 9) { /* new carry created */
			num3[i] = num3[i] - 10;
			carry = 1;
		}
		else /* no carry created */
			carry = 0;
	}

	if (num3[SIZE] == 2) { /* sum too large */
		num3[SIZE] = 0; /* Go modulo 2*10^{SIZE} */
	}
	if (num3[SIZE] == 3) { /* sum too large */
		num3[SIZE] = 1; /* Go modulo 2*10^{SIZE} */
	}

	return;
} /* end of add_numbers() */


/* Output the given number. It first converts the number
 * from its representation modulo 2*10^{SIZE} to normal.
 */

void output_number(char number[])
{
	int i;

	/* First convert to normal representation */
	number2modular(number);

	/* Skip the leading zeroes */
	for (i = SIZE-1; i >= 0; i--)
		if (number[i] > 0)
			break;
	
	if (i == -1) { /* the sum is zero! */
		printf("The sum is: 0\n");
		return;
	}

	printf("The sum is: ");
	if (number[SIZE] == 1) /* negative number */
		putchar('-');

	for (; i >= 0; i--)
		putchar(number[i]+'0');
	printf("\n");
}

/* Skips white spaces in the input and returns the first
 * non-white space symbol. The white spaces are defined to
 * be BLANK, NEW LINE, and TAB symbols.
 */
char skip_blanks()
{
	char c;

	c = getchar();

	for (; (c == ' ') || (c == '\n') || (c == '\t'); )
		c = getchar();
	
	return c;
}