Go: package main

import "fmt"

func main() {
	stack := []int{}
	for {
		var a int
		i, _ := fmt.Scan(&a)
		if i == 0 {
			break
		}
		if a == 0 {
			fmt.Println(stack[len(stack)-1])
			stack = stack[:len(stack)-1]
			continue
		}
		stack = append(stack, a)
	}
}

C++: #include <iostream>
#include <stack>

int main(){
	std::stack<int> st;

	//car's number
	int num = 0;

    //Until the end of input
	while(std::cin >> num){
        //if num = 0, output and delete
		if(num == 0){
			std::cout << st.pop() << std::endl;
        //if num != 0, input    
		} else {
			st.push(num);
		}
	}
}

C++: #include <stdio.h>
int main(){
	int stack[100000],i=0;
	while(scanf("%d",&stack[i])!=EOF){
		if(stack[i]==0){
			printf("%d\n",stack[i-1]);
			i--;
		}
		else i++;
	}
	return 0;
}

C++: #include<iostream>
#include<stack>

int main(){
	int n;
	std::stack<int>sta;
	while(std::cin>>n){
		if(n!=0)sta.push(n);
		else{
			std::cout<<sta.top()<<std::endl;
			sta.pop();
		}
	}
	return 0;
}

C++: #include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit(b) (1ll << (b))

using namespace std;

using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;

inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T power(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }

void solve() {
  stack<int> st;
  int n;
  while (cin >> n) {
    if (n == 0) {
      cout << st.top() << '\n';
      st.pop();
    } else {
      st.push(n);
    }
  }
}

C++: #include <iostream>
#include <stack>
using namespace std;

int main(){
	int n;
	stack<int> stack;
	while(cin >> n){
		if(n == 0){
			cout << stack.top() << endl;
			stack.pop();
		}
		else {
			stack.push(n);
		}
	}
	return 0;
}

C++: #include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int a,b=-1;
int main(){
	vector<int> train;
	while(cin>>a){
		if(a==0){
			cout<<train[b]<<endl;
			train.pop_back();
			b--;
		}
		else{
			train.push_back(a);
			b++;
		}
	}
	return 0;
}

C++: #include <iostream>
using namespace std;

int main(){
  int stack[10];
  int *head;
  int car_num;

  head=stack;
  while(cin>>car_num){
    if(car_num>0){
      *head=car_num;
      head++;
    }
    else {
      head--;
      printf("%d\n", *head);
    }
  }

  return 0;
}

C++: #include<stack>
#include<iostream>
using namespace std;
void main(){
	stack<int> train;
	int n;
	while(cin >> n){
		if(n != 0)
			train.push(n);
		else{
			cout << train.top() << endl;
			train.pop();
		}
	}
}

C++: #include<stdio.h>
#include<stack>

int main(){
	int data[100]={0},i=0;
	std::stack<int> train;
	while(data[i] != EOF){
		scanf("%d",&data[i]);
		i++;
	}
	i=0;
	train.push(data[i]);
	i=1;
	while(1){
		if(! train.empty()){
			if(data[i]==0){
				printf("%d\n",train.top());
				train.pop();
			}else{
				train.push(data[i]);
			}
		i++;
		}else{
			break;
		}
	}
	return 0;
}

C++: #define scanf_s scanf
#include <stdio.h>
#include <string>
#include <iostream>
#include <math.h>
using namespace std;
#define MAX 150
int main(void)
{
	int w, n, now = 0, cou = 0;
	int list[MAX] = { 0 };
	int li[MAX] = { 0 };
	do{	
		scanf_s("%d", &n);
		if (n != 0) { list[now] = n; ++now; }
		else { --now; 	printf("%d\n", list[now]);}
	} while (now != 0);
}

C++: #include <bits/stdc++.h>
#include <chrono>
using namespace std;

using _i64 = int64_t;
using _u64 = uint64_t;
using _f64 = double;

#define endl "\n"

#define _for(i, start, end) for(_i64 i = (_i64)start; i < (_i64)end; ++i)
#define _rep(i, number) _for(i, 0, number)
#define _foreach(e, data) for(auto& e : data)
#define _all(data) data.begin(), data.end()

template<typename type>
_i64 _size(const type& data) { return static_cast<_i64>(data.size()); }
template<typename type, size_t size>
_i64 _size(const type (&)[size]) { return static_cast<_i64>(size); }

enum _flag : bool { able = true, disable = false };

struct _time {
    _time(_flag flag) { check = flag; if(!check) { return; } gettime(start); }
    ~_time() {
        if(!check) { return; }; gettime(end);
        _i64 elapse = chrono::duration_cast<chrono::milliseconds>(end - start).count();
        cout << endl << "Time: " << elapse << " ms" << endl;
    }
    private:
    using _timer = chrono::time_point<chrono::system_clock>;
    _timer start, end; bool check;
    void gettime(_timer& time) { time = chrono::system_clock::now(); }
};

struct _ini { _ini() { ios::sync_with_stdio(false); cin.tie(nullptr); } } _ini;

int main() {
    {
        _time time(disable);
        stack<_i64> vehicle; _i64 quere;
        while(cin >> quere) {
            if(quere == 0) { cout << vehicle.top() << endl; vehicle.pop(); }
            else { vehicle.push(quere); }
        }
    }
    return 0;
}

C++: // 車両入れ替え

#include <iostream>
using namespace std;

int main() {
    int pos = -1;
    int input;
    int senro[100];

    while (cin >> input) {
        if (input != 0) {
            pos++;
            senro[pos] = input;
        } else if (input == 0) {
            if (pos >= 0) {
                cout << senro[pos] << "\n";
                pos--;
            } else {
                cout << "error???" << "\n";
                return 1;
            }
        }
    }
    return 0;
}

C++: #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <stack>

using namespace std;

int main(void){
    int i,j,d;
    stack<int> train;
    while(cin >> d){
        if(d==0){
            cout << train.top() << endl;
            train.pop();
        }
        else train.push(d);
    }
    return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
stack<int> s;

int main(){
  int tmp;
  while(scanf("%d", &tmp)!=EOF){
    if(tmp!=0) s.push(tmp);
    else{
      printf("%d\n", s.top());
      s.pop();
    }
  }
  return 0;
}

C++: #include<stdio.h>
int main(void)
{
	int n[1000],z,w;
	w=0;
	while(scanf("%d",&z)!=EOF){
		w++;
		if(z!=0){
			n[w]=z;
		}
		else if(z==0){
			printf("%d\n",n[w-1]);
			w-=2;
		}
	}
	return 0;
}