Go: package main

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

func main() {
	var total int
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		line := scanner.Text()
		strs := strings.Split(line, " ")

		for _, s := range strs {
			x, _ := strconv.Atoi(s)
			total += x
		}
	}

	fmt.Printf("%v\n", total)
}

C++: #include "bits/stdc++.h"
#pragma GCC optimize("Ofast")

// Begin Header {{{
using namespace std;

#ifndef DEBUG
#define dump(...)
#endif

#define all(x) x.begin(), x.end()
#define rep(i, b, e) for (intmax_t i = (b), i##_limit = (e); i < i##_limit; ++i)
#define reps(i, b, e) for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)
#define repr(i, b, e) for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)
#define var(Type, ...) Type __VA_ARGS__; input(__VA_ARGS__)

constexpr size_t    operator""_zu(unsigned long long value) { return value; };
constexpr intmax_t  operator""_jd(unsigned long long value) { return value; };
constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };

constexpr int INF = 0x3f3f3f3f;
constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;

template <class T, class Compare = less<>>
using MaxHeap = priority_queue<T, vector<T>, Compare>;
template <class T, class Compare = greater<>>
using MinHeap = priority_queue<T, vector<T>, Compare>;

inline void input() {}
template <class Head, class... Tail>
inline void input(Head&& head, Tail&&... tail) {
    cin >> head;
    input(forward<Tail>(tail)...);
}

template <class T>
inline istream& operator>>(istream &is, vector<T> &vec) {
    for (auto &e: vec) {
        is >> e;
    }
    return is;
}

inline void output() { cout << "\n"; }
template <class Head, class... Tail>
inline void output(Head&& head, Tail&&... tail) {
    cout << head;
    if (sizeof...(tail)) {
        cout << " ";
    }
    output(forward<Tail>(tail)...);
}

template <class T>
inline ostream& operator<<(ostream &os, const vector<T> &vec) {
    static constexpr const char *delim[] = {" ", ""};
    for (const auto &e: vec) {
        os << e << delim[&e == &vec.back()];
    }
    return os;
}

template <class T>
inline vector<T> makeVector(const T &initValue, size_t sz) {
    return vector<T>(sz, initValue);
}

template <class T, class... Args>
inline auto makeVector(const T &initValue, size_t sz, Args... args) {
    return vector<decltype(makeVector<T>(initValue, args...))>(sz, makeVector<T>(initValue, args...));
}

template <class Func>
class FixPoint : Func {
public:
    explicit constexpr FixPoint(Func&& f) noexcept : Func(forward<Func>(f)) {}

    template <class... Args>
    constexpr decltype(auto) operator()(Args&&... args) const {
        return Func::operator()(*this, std::forward<Args>(args)...);
    }
};

template <class Func>
static inline constexpr decltype(auto) makeFixPoint(Func&& f) noexcept {
    return FixPoint<Func>{forward<Func>(f)};
}

template <class Container>
struct reverse_t {
    Container &c;
    reverse_t(Container &c) : c(c) {}
    auto begin() { return c.rbegin(); }
    auto end() { return c.rend(); }
};

template <class Container>
auto reversed(Container &c) {
    return reverse_t<Container>(c);
}

template <class T>
inline bool chmax(T &a, const T &b) noexcept {
    return b > a && (a = b, true);
}

template <class T>
inline bool chmin(T &a, const T &b) noexcept {
    return b < a && (a = b, true);
}

template <class T>
inline T diff(const T &a, const T &b) noexcept {
    return a < b ? b - a : a - b;
}
// End Header }}}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.setf(ios_base::fixed);
    cout.precision(10);

    vector<intmax_t> v(4); input(v); output(accumulate(all(v), 0));

    return 0;
}

C++: #include<iostream>
#include<stdio.h>
#include<string>
#include<cmath>
#include<math.h>
#include<vector>
#include<algorithm>
#include<map>
#include<unordered_map>
#pragma warning(disable: 4996)
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;

int main() {

	int R, B, W, G;
	cin >> R >> B >> W >> G;
	cout << R + B + W + G << endl;

	return 0;
}

C++: #include<cstdio>
#include<algorithm>
using namespace std;
int main(void)
{
	int a,b,c,d;
	scanf("%d %d %d %d",&a,&b,&c,&d);
	printf("%d\n",a+b+c+d);
	return 0;
}

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

using namespace std;

int main() {
	int r, b, w, g;

	cin >> r >> b >> w >> g;
	cout << r + b + w + g << endl;

	return 0;
}

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

int main(){
    int R,B,W,G;
    
    cin >> R >> B >> W >> G;

    cout << R+B+W+G << endl;


    return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
int main(){
int A;
int B;
int C;
int D;

cin >> A >> B >> C >> D;

cout << A + B + C + D << endl;
}

C++: /*
Dear ToM,
Congratulations on your graduation!
You did a great job!
     ☆ﾟ*＠*ﾟ☆
　　(＠*｡☆｡*＠
　 /☆｡*＠ﾟ*☆
▲/／｡＠｡*☆＠*
　▼―ｰ｡*＠ﾟ*☆
*/

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

#define REP(i,s,n) for(int i=s; i<n; ++i)
#define rep(i,n) REP(i,0,n)
#define SORT(c) sort((c).begin(),(c).end())
#define IINF INT_MAX
#define LLINF LLONG_MAX
#define DEBUG false

typedef long long ll;
typedef pair<int, int> ii;

int main(){
  ll r, b, w, g;
  cin >> r >> b >> w >> g;
  cout << r + b + w + g << endl;

	return 0;
}

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

using namespace std;

main(){
	int a,b,c,d;
	cin >> a >> b >> c >> d;
	printf("%d\n",a+b+c+d);
}

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

int main() {
  int R, B, W, G;
  cin >> R >> B >> W >> G;
  cout << R + B + W + G << endl;
  return 0;
}

C++: #include <iostream>
using namespace std;
int main(void){
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    cout<<a+b+c+d<<endl;
}

C++: #include<iostream>
using namespace std;
int main(){
    int r,b,w,g; cin>>r>>b>>w>>g;
    cout<<r+b+w+g<<endl;
    return 0;
}

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

int main() {
  int R, B, W, G;
  cin >> R >> B >> W >> G;
  cout << R + B + W + G << endl;
}

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

int main(){
    
    int i, x=0, n;
    
    for(i=0;i<4;i++){
        cin >> n;
        x+=n;
    }
    cout << x << endl;
}

C++: #include<cstdio>
#include<functional>
#include<algorithm>
using namespace std;
int main(void)
{
	int r,b,w,g,sum;
	scanf("%d %d %d %d",&r,&b,&w,&g);
	sum=r+b+w+g;
	printf("%d\n",sum);
	return 0;
}

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

using i64 = int64_t;

int main(){
    int r, b, w, g;
    cin >> r >> b >> w >> g;
    cout << r + b + w + g << endl;

    return 0;
}

C++: #include <bits/stdc++.h>
typedef long long lint;
using namespace std;
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)

int main() {
    int r,b,w,g; cin >> r >> b >> w >> g;
    cout << r+b+w+g << endl;
}

C++: #include <iostream>
using namespace std;
int main(){
    int a,b,c,d;cin>>a>>b>>c>>d;
    cout << a+b+c+d << endl;
}

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

using ll = long long int;
using P = pair<int, int>;
using P3 = pair<ll,P>;
using PP = pair<P, P>;
constexpr int INF = 1 << 30;
constexpr ll MOD = ll(1e9) + 7;
constexpr int di[] = {0, 1, 0, -1};
constexpr int dj[] = {1, 0, -1, 0};
constexpr double EPS = 1e-8;


bool solve(){
    int ans = 0;
    for(int i=0;i<4;i++){
        int a;
        cin >> a;
        ans += a;
    }
    cout << ans << endl;
    return false;
}

int main(){
    solve();
    // int t; cin >> t; for(;t>0;t--) solve();
    return 0;
}

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


signed main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
 
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    cout << a+b+c+d<<endl;
    
}