tower of hanoi non recursion

#include <stdio.h>
#include<math.h>
#define MX_SIZE 1024

void HANOI( int n , int i , int j , int k ) ;

/* initializing max size and top */

int stack_n[ MX_SIZE ] ;
int stack_i[ MX_SIZE ] ;
int stack_j[ MX_SIZE ] ;
int stack_k[ MX_SIZE ] ;
int top_n ;
int top_i ;
int top_j ;
int top_k ;

/* function for push and pop */

void push_n( int n ) ;
void push_i( int n ) ;
void push_j( int n ) ;
void push_k( int n ) ;
int pop_n( void ) ;
int pop_i( void ) ;
int pop_j( void ) ;
int pop_k( void ) ;
void push( int n , int i , int j , int k ) ;
int pop( int &n , int &i , int &j , int &k ) ;
void empty_stack( void ) ;
int stack_is_empty( void ) ;

void HANOI( int n , int i , int j , int k )
{
    empty_stack() ;
    push( n , i , j , k ) ;
    while( !stack_is_empty() )
    {
        pop( n , i , j , k ) ;
        if( n == 1 )
        {
            printf( "move disk from %d to %d . \n" , i , k ) ;
        }
        else
        {
            push( n - 1 , j , i , k ) ;
            push( 1 , i , j , k ) ;
            push( n - 1 , i , k , j ) ;
        }
    }
}

int main( void )
{
    int disks ;
    printf("Enter the number of disks: ");
    scanf( "%d" , &disks ) ;

    int move_count = pow(2,disks)-1;
    printf("\nTotal moves: %d\n\n",move_count);

    HANOI( disks , 1 , 2 , 3 ) ;

    return 0 ;
}



void push_n( int n )
{
    top_n = top_n + 1 ;
    stack_n[ top_n ] = n ;
}

void push_i( int n )
{
    top_i = top_i + 1 ;
    stack_i[ top_i ] = n ;
}

void push_j( int n )
{
    top_j = top_j + 1 ;
    stack_j[ top_j ] = n ;
}

void push_k( int n )
{
    top_k = top_k + 1 ;
    stack_k[ top_k ] = n ;
}

int pop_n( void )
{
    int number ;
    number = stack_n[ top_n ] ;
    top_n = top_n - 1 ;
    return number ;
}

int pop_i( void )
{
    int number ;
    number = stack_i[ top_i ] ;
    top_i = top_i - 1 ;
    return number ;
}



int pop_j( void )
{
    int number ;
    number = stack_j[ top_j ] ;
    top_j = top_j - 1 ;
    return number ;
}



int pop_k( void )
{
    int number ;
    number = stack_k[ top_k ] ;
    top_k = top_k - 1 ;
    return number ;
}

void push( int n , int i , int j , int k )
{
    push_n( n ) ;
    push_i( i ) ;
    push_j( j ) ;
    push_k( k ) ;
}

int pop( int &n , int &i , int &j , int &k )
{
    n = pop_n() ;
    i = pop_i() ;
    j = pop_j() ;
    k = pop_k() ;
}

void empty_stack( void )
{
    top_n = -1 ;
    top_i = -1 ;
    top_j = -1 ;
    top_k = -1 ;
}

int stack_is_empty( void )
{
    if( top_n == -1 && top_i == -1 && top_j == -1 && top_k == -1 )
    {
        return 1 ;
    }
    else
    {
        return 0 ;
    }
}