int main(void){
	FILE *in;
	int i;

	/* Create file handle */
	if((in = fopen(FILENAME, "r")) == NULL){
		printf("Unable to open file '%s'\n", FILENAME);
		return 1;
	}
    
	/* Construct sum and current number lists */
    list *sum = malloc(sizeof(list));
    constructList(sum, LENGTH);
 	list *currNum = malloc(sizeof(list));
 	constructList(currNum, LENGTH);
	
	/* Compute the large number by repetitively loading the numbers from file and adding to sum */
	loadNumber(in, sum);
	for (i = 1; i < NUMBERS; i++) {
		loadNumber(in, currNum);
		addNumber(sum, currNum);
	}
	
	/* Print the first 10 digits of sum */
	printNumber(sum);

	/* Deconstruct all constructs */
    fclose(in);
 	destructList(sum);
    free(sum);
	free(currNum);
    
    return 0;
}

void Print::print(unsigned long long n, int base) {
    if (base == BYTE) {
        write((uint8)n);
    } else {
        printNumber(n, base);
    }
}

void Noritake_VFD_GU7000::print(long number, uint8_t base) {
    if (number < 0) {
        print('-');
        number = -number;
    }
    printNumber(number, base);
}

void Print::printf(const char *str, ...) {
  va_list args;
  va_start(args, str);
  while(uint8_t c = *str++) {
    switch(c) {
      case '%': {
        c = *str++;
        if(c) {
          switch(c) {
            // TODO
            case 'd': {
              int x = va_arg(args, int);
              printNumber(x, 10);
            } break;
            case 's': {
              const char *x = va_arg(args, const char *);
              print(x);
            } break;
            case '%': {
              write(c);
            } break;
            default: {
              write('%');
              write(c);
            };
          };
        } else {
          write('%');
        };
      } break;
      default: {
        write(c);
      } break;
    };
  };

int main() {
    int size = 0;
    char strNumber[9];
    scanf("%d %s", &size, strNumber);
    
    while (size != 0 || atoi(strNumber) != 0) {
        setLcdSize(size);
        int length = strlen(strNumber);
        
        int i;
        for (i = 0; i < length; i++) {
            int n = strNumber[i] - '0';
            printNumber(n, i);
        }
        
        for (i = 0; i < nLines; i++) {
            int n;
            for (n = 0; n < length; n++) {
                int j;
                for (j = 0; j < nColumns; j++) {
                    printf("%c", lcdNumbers[n][i][j]);
                }
                if (n < length - 1) {
                    printf(" "); //column of blanks
                }
            }
            printf("\n");
        }
        printf("\n");

        scanf("%d %s", &size, strNumber);
    }
    return 0;
}

void Com::print(long value) {
    if(value<0) {
        HAL::serialWriteByte('-');
        value = -value;
    }
    printNumber(value);
}

void IF_show_stackV(void)
{
void * Next;
struct Var * N;
    Next = stackV;
    while (Next != VIDE) {
       N = (struct Var*) Next;
       printf(" %-25s : Type ",N->l);
       switch(N->t) {
          case VT_I :
            printf("initial (NULL)");
            break;
          case VT_B :
            printf("Boolean ");
            if (N->b) printf("TRUE"); else printf("FALSE");
            break;
          case VT_C :
            printf("String \"%s\"", (char*)N->a);
            break;
          case VT_N :
            printf("Number ");
            printNumber(N->a);
            break;
          case VT_L :
            printf("Lib. Fct. %s", libByAddr(N->a));
            break;
          case VT_F :
            printf("User Fct. %s", fctByAddr(N->a));
            break;
       }
       printf("\n");
       Next = N->n;
    }
    printf("<end of variable list>\n");
}

size_t Print::print(unsigned long n, int base)
{
	if (base == 0)
	{
		return write(n);
	}
	return printNumber(n, base);
}

void WaspXBee::print(long n)
{
  if (n < 0) {
    print('-');
    n = -n;
  }
  printNumber(n, 10);
}

void printf(const char * msg, ...)
{
	unsigned char *memory = (unsigned char *)VIDEO_MEMORY;
	unsigned short i = 0;
	char c = ' ';

	unsigned char *p = (char*)&msg + sizeof(char*);
	while(1)
	{
		c = *(msg+(i++));
		if(c == '%')
		{
			char specifier = *(msg+(i++));
			switch(specifier)
			{
				case 'c':
					c = (unsigned char)*((int*)p);
					p += sizeof(int);
				break;
				case 'u':
					printNumber((unsigned int)*((int*)p), 10);
					p += sizeof(int);
					continue;
				case 'x':
					printNumber((unsigned int)*((int*)p), 16);
					p += sizeof(int);
					continue;
				case 's':
					printString((const unsigned char*)*((int*)p));
					p += sizeof(int);
					continue;
				default:
				break;
			}
		}
		else if(c == '\n')
		{
			nextLine();
			continue;
		}
		if(c == 0)
			break;
		putch(c);
		incrementCursor();
	}
}

void Print::print(long n)
{
  if (n < 0) {
    print('-');
    n = -n;
  }
  printNumber(n, 10);
}

void writeDecDigits(text_t *p, int val, int width)
{
  if(val < 0) {
    val = -val;
    writeChar(p, '-');
  }
  printNumber(p, val, 10, width, ' ');
}

void printStack(stack *stk){
  cell *top = stk->top;
  while(top != NULL){
    printNumber(top->number);
    putchar('\n');
    top = top->prev;
  }
}

void SWSerLCDpa::print(long n)
{
    if (n < 0) {
        print('-');
        n = -n;
    }
    printNumber(n, 10);
}

void SoftwareSerial::print(long n)
{
  if (n < 0) {
    print('-');
    n = -n;
  }
  printNumber(n, 10);
}

void printNumber(int n)	// for n > 0
{	// 1234567
	if(n)
	{
		printNumber(n/10);		// 214/10 = 21
		cout<<n%10;				// 214%10 = 4
	}
}

int main(int argc, char const *argv[])
{
	int x;
	scanf("%d", &x);

	printNumber(x);
	printf("%s\n", "");
	return 0;
}

void Print::print(long n, int base)
{
  if (base == 0)
    print((char) n);
  else if (base == 10)
    print(n);
  else
    printNumber(n, base, 0);
}

void printGeneral(parseTree curNode, FILE* fp)
{
    if(curNode->tk->sym < nNonTerminals)
        printNonTerminal(curNode, fp);
    else if(curNode->tk->sym == NUM || curNode->tk->sym == RNUM )
        printNumber(curNode, fp);
    else
        printTerminal(curNode, fp);
}

size_t Print::print(unsigned long long n, int base) {
size_t c=0;
    if (base == BYTE) {
        c= write((uint8)n);
    } else {
        c= printNumber(n, base);
    }
	return c;
}