Add two numbers represented by stack

/*
    C Program 
    Add two numbers represented by stack
*/
#include <stdio.h>
#include <stdlib.h>

// Define stack node
struct StackNode
{
    int element;
    struct StackNode *next;
};
// Define a custom stack
struct MyStack
{
    struct StackNode *top;
    int size;
};

struct MyStack *newStack()
{
    //Make a stack
    struct MyStack *stack = (struct MyStack *) malloc(sizeof(struct MyStack));
    if (stack != NULL)
    {
        //Set node values
        stack->top = NULL;
        stack->size = 0;
    }
    else
    {
        printf("\nMemory overflow when create new stack\n");
    }
}
// Returns the status of empty or non empty stacks
int isEmpty(struct MyStack *stack)
{
    if (stack->size > 0 && stack->top != NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
// Add node at the top of stack
void push(struct MyStack *stack, int element)
{

    // Make a new node
    struct StackNode *node = (struct StackNode *) malloc(sizeof(struct StackNode));
    
    if (node == NULL)
    {
        printf("\nMemory overflow when create new stack Node \n");
    }
    else
    {
        node->element = element;
        node->next    = stack->top;
    }

    // Add stack element
    stack->top = node;
    stack->size++;
}
// return top element of stack
int peek(struct MyStack *stack)
{
    return stack->top->element;
}
// Remove top element of stack
void pop(struct MyStack *stack)
{
    if (isEmpty(stack) == 0)
    {
        struct StackNode *temp = stack->top;
        // Change top element of stack
        stack->top = temp->next;
        // remove previous top
        free(temp);
        temp = NULL;
        stack->size--;
    }
}
// Perform of addition of two numbers in stack
void addNumber(struct MyStack*s1,struct MyStack*s2)
{
    // This is backup stack
    struct MyStack *result = newStack();

    int remainder = 0;

    int sum = 0;

    while(isEmpty(s1)==0 || isEmpty(s2) == 0)
    {

        if(isEmpty(s1)==0 && isEmpty(s2) == 0)
        {
            // When both stack element exists
            sum = remainder + peek(s1) + peek(s2);
            pop(s1);
            pop(s2);

           
        }
        else
        {
            if(isEmpty(s1)==0 )
            {
                // When s1 element exists
                sum = remainder + peek(s1);
                pop(s1);
            }
            else
            {
                 // When s2 element exists
                sum = remainder + peek(s2);
                pop(s2);
            }

        }
        // Add sum into stack
        push(result,sum % 10);

        remainder = sum / 10;
    }
    // When remainder value exists
    while(remainder > 0)
    {
        push(result,remainder % 10);

        remainder = remainder / 10;
    }

    // Put result into stack s1
    while(isEmpty(result)==0)
    {
        push(s1,peek(result));

        pop(result);
    }
    
}
// Print stack elements in reverse order
void printData(struct MyStack *s)
{
    if(isEmpty(s)==1)
    {
        return;
    }
    int data = peek(s);
    pop(s);
    printData(s);
    printf("  %d", data);
    push(s,data);
  
   
}
// Handle request to print stack elements
void printStack(struct MyStack*s1,struct MyStack*s2)
{
    printf("\n Stack 1 \n");
    printData(s1);
    printf("\n Stack 2 \n");
    printData(s2);
}
int main()
{   
    // Create two empty stack
    struct MyStack*s1 = newStack();
    struct MyStack*s2 = newStack();

    // First stack
    push(s1,9);
    push(s1,8);
    push(s1,9);
    
    // Second stack
    push(s2,4);
    push(s2,2);
    push(s2,8);

    printStack(s1,s2);
    addNumber(s1,s2);
    printf("\n Result \n");
    printData(s1);
    printf("\n");

    return 0;
}

Output

 Stack 1
  9  8  9
 Stack 2
  4  2  8
 Result
  1  4  1  7