Tower of Hanoi (Non recursive)

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

void HANOI( int n , int i , int j , int k ) ;
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 ;
void push_n( int n ) ;
int pop_n( void ) ;
void push_i( int n ) ;
int pop_i( void ) ;
void push_j( int n ) ;
int pop_j( void ) ;
void push_k( int n ) ;
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 ) ;

int main( void ) {

    top_n = -1 ;
    top_i = -1 ;
    top_j = -1 ;
    top_k = -1 ;

    int disks ;
    scanf( "%d" , &disks ) ;

    HANOI( disks , 1 , 2 , 3 ) ;

    return 0 ;
}

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 ) ;
        }
    }
}

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

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

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

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

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

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

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

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 ;
    }
}