（C言語）スタックを用いた迷路の経路探索のエラーについて

struct coord* pop(struct stack* s) {
    if (s->top <= 0) {
        return NULL;
    }
-   struct coord *alt = &s->buf[s->top];
    s->top = s->top - 1;
+   struct coord *alt = &s->buf[s->top];
    return alt;
}

####################
#S    #            #
# ### # ########## #
#     #      #     #
### ### #### #### ##
#     #      #     #
# ####### #### #   #
#  #   #  #    #####
#    #    #       G#
####################

####################
#.....#............#
# ###.#.##########.#
#  ...#......#   ..#
###.### ####.####.##
#...  #  ....#.....#
#.#######.####.#...#
#..#...# .#....#####
# ...#....#........#
####################

#include <stdio.h>
#include <stdlib.h>
#pragma warning(disable : 4996)

#define BUF_SIZE 100
#define SIZE_X 10
#define SIZE_Y 21

struct coord {
    int x;
    int y;
    int px;
    int py;
};

struct stack {
    struct coord buf[BUF_SIZE];
    int top;
};

int push(struct stack* s, struct coord p) {
    if (s->top > BUF_SIZE - 1) {
        return -1;
    }
    s->buf[s->top] = p;
    s->top++;
    return 1;
}

struct coord* pop(struct stack* s) {
    if (s->top <= 0) {
        return NULL;
    }
    s->top = s->top - 1;
    struct coord *alt = &s->buf[s->top];
    return alt;
}

void display_stack(struct stack* s) {
    for (int i = 0; i < s->top; i++) {
        printf("(%d,%d) ", s->buf[i].x, s->buf[i].y);
    }
    printf("\n");
}

void read_map(char map[][SIZE_Y]) {
    FILE* fp;
    if ((fp = fopen("meiro1.txt", "r")) == NULL) {
        printf("File cannot be opened!");
        exit(1);
    }
    for (int i = 0; i < SIZE_X; i++) {
        for (int j = 0; j < SIZE_Y; j++) {
            int ch = fgetc(fp);
            map[i][j] = ch;
        }
    }
    fclose(fp);
}

void print_map(char map[][SIZE_Y]) {
    for (int i = 0; i < SIZE_X; i++) {
        for (int j = 0; j < SIZE_Y; j++) {
            printf("%c", map[i][j]);
        }
    }
}

void record_path(struct coord rec[][SIZE_Y], int x, int y, int px, int py) {
    rec[x][y].px = px;
    rec[x][y].py = py;
}

void print_path(char map[][SIZE_Y], struct coord rec[][SIZE_Y], int gx, int gy) {
    int x = gx;
    int y = gy;
    while (x != -1 && y != -1) {
        map[x][y] = '.';
        int px = rec[x][y].px;
        int py = rec[x][y].py;
        x = px;
        y = py;
    }
    print_map(map);
}

void search(char map[][SIZE_Y], struct coord rec[][SIZE_Y], int visit[][SIZE_Y], struct stack* s, int* gx, int* gy)
{
    struct coord tmp;
    tmp.x = *gx;
    tmp.y = *gy;
    tmp.px = -1;
    tmp.py = -1;
    
    if (push(s, tmp) == -1) {
        printf("Stack Overflow.\n");
        printf("a");
    }
    
    while (1) {
        struct coord* p = pop(s);
        if (p == NULL) {
            printf("Stack Underflow.\n");
            break;
        }
        int x = p->x;
        int y = p->y;
        int px = p->px;
        int py = p->py;
        
        visit[x][y] = 1; // 新たに訪れた位置をマーク
        record_path(rec, x, y, px, py);

        // ゴールに到達したら終了
        if (map[x][y] == 'G') {
            *gx = x;
            *gy = y;
            break;
        }
        
        // 上、下、左、右に進む（縦型探索）
        int dx[] = { -1, 1, 0, 0 };
        int dy[] = { 0, 0, -1, 1 };
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i]; // 移動先のX座標
            int ny = y + dy[i]; // 移動先のY座標
            if (!(nx < 0 || nx >= SIZE_X || ny < 0 || ny >= SIZE_Y ||
                  map[nx][ny] == '#')) { // 迷路の範囲内を探索しているならば
                tmp.x = nx;
                tmp.y = ny;
                tmp.px = x;
                tmp.py = y;
                if (visit[nx][ny] == 1) continue;
                else if (push(s, tmp) == -1) {
                    printf("Stack Overflow.\n");
                    printf("i");
                }
            }
        }
    }
}

int main(int argc, const char * argv[]) {
    char map[SIZE_X][SIZE_Y];
    struct coord rec[SIZE_X][SIZE_Y];
    int visit[SIZE_X][SIZE_Y] = { 0 }; // 訪問済み配列を0で初期化
    struct stack s;
    int gx=0;
    int gy=0;

    read_map(map);

    s.top = 0;
    for (int i = 0; i < SIZE_X; i++) {
        for (int j = 0; j < SIZE_Y; j++) {
            rec[i][j].x = -1;
            rec[i][j].y = -1;
            rec[i][j].px = -1;
            rec[i][j].py = -1;
            if (map[i][j] == 'S') {
                gx = i;
                gy = j;
            }
        }
    }

    print_map(map);
    
    search(map, rec, visit, &s, &gx, &gy);
    print_path(map, rec, gx, gy);
    
    return 0;
}