Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var scanner = bufio.NewScanner(os.Stdin)

func nextString() string {
	scanner.Scan()
	return scanner.Text()
}

func nextInt() (int, error) {
	n, err := strconv.Atoi(nextString())
	return n, err
}

func main() {
	scanner.Split(bufio.ScanWords)

	stack := []int{}
	for {
		n, err := nextInt()
		if err != nil {
			break
		}

		if n == 0 { // pop
			fmt.Println(stack[len(stack)-1])
			stack = stack[0:(len(stack) - 1)]
		} else { // push
			stack = append(stack, n)
		}
	}
}

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

using namespace std;

int main(int argc, char const *argv[]){
    int input; 
    stack<int> train_stack;
    vector<int> order;

    cin>>input;
    train_stack.push(input);
    while (1){
        cin>>input;
        if (input==0){
            cout<<train_stack.top()<<endl;
            train_stack.pop();
        }
        else{
            train_stack.push(input);
        }
    }

    return 0;
}

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

std::stack<int> s;

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

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

int main()
{
	int n;
	vector<int> cars;
	while (cin >> n) {
		if (n==0)  {
			cout << cars.back() << endl;
			cars.pop_back();
		}
		else
			cars.push_back(n);
	}

	return 0;
}

C++: #include <stack>
#include <iostream>
using namespace std;
int main()
{
	stack<int> data;
	int input;
	
	while (cin >> input)
	{
		if (input)
		{
			data.push(input);
		}
		else
		{
			cout << data.top() << endl;
			data.pop();
		}
	}
}

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