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

using i64 = long long;
#define endl '\n'

class LinkCutTree
{
public:
    struct Node
    {
        int fa;
        array<int, 2> son;
        bool rev;
        int sum, val;
        Node() : fa(0), son({0, 0}), rev(false), sum(0), val(0) {}
    };
    vector<Node> tree;

    bool isroot(int x)
    {
        int fa = tree[x].fa;
        return tree[fa].son[0] != x && tree[fa].son[1] != x;
    }

    void pushup(int x)
    {
        int ls = tree[x].son[0], rs = tree[x].son[1];
        tree[x].sum = tree[x].val + tree[ls].sum + tree[rs].sum;
    }

    void pushrev(int x)
    {
        if (!x)
            return;
        swap(tree[x].son[0], tree[x].son[1]);
        tree[x].rev ^= 1;
    }

    void pushdown(int x)
    {
        if (tree[x].rev)
        {
            pushrev(tree[x].son[0]);
            pushrev(tree[x].son[1]);
            tree[x].rev = 0;
        }
    }

    void push(int x)
    {
        if (!isroot(x))
            push(tree[x].fa);
        pushdown(x);
    }

    void rotate(int x)
    {
        int y = tree[x].fa;
        int z = tree[y].fa;
        int k = tree[y].son[1] == x;
        if (!isroot(y))
            tree[z].son[tree[z].son[1] == y] = x;
        tree[x].fa = z;
        tree[y].son[k] = tree[x].son[k ^ 1];
        if (tree[x].son[k ^ 1])
            tree[tree[x].son[k ^ 1]].fa = y;
        tree[y].fa = x;
        tree[x].son[k ^ 1] = y;
        pushup(y);
    }

    void splay(int x)
    {
        int y, z;
        push(x);
        while (!isroot(x))
        {
            y = tree[x].fa;
            z = tree[y].fa;
            if (!isroot(y))
                tree[z].son[0] == y ^ tree[y].son[0] == x ? rotate(x) : rotate(y);
            rotate(x);
        }
        pushup(x);
    }

    void access(int x)
    {
        for (int y = 0; x; y = x, x = tree[x].fa)
        {
            splay(x);
            tree[x].son[1] = y;
            pushup(x);
        }
    }

    void makeroot(int x)
    {
        access(x);
        splay(x);
        pushrev(x);
    }

    void split(int x, int y)
    {
        makeroot(x);
        access(y);
        splay(y);
    }

    void link(int x, int y)
    {
        makeroot(x);
        tree[x].fa = y;
    }

    void cut(int x, int y)
    {
        makeroot(x);
        access(y);
        splay(y);
        if (tree[y].son[0] != x || tree[x].son[1])
            return;
        tree[x].fa = tree[y].son[0] = 0;
        pushup(y);
    }

    int findroot(int x)
    {
        access(x);
        splay(x);
        while (tree[x].son[0])
        {
            pushdown(x);
            x = tree[x].son[0];
        }
        pushdown(x);
        return x;
    }

    LinkCutTree(int n, vector<int> &arr) : tree(n + 1)
    {
        for (int i = 1; i <= n; i++)
            tree[i].val = tree[i].sum = arr[i];
    }
};

signed main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n = 2;
    vector<int> arr(n + 1);
    for (int i = 1; i <= n; i++)
        cin >> arr[i];
    LinkCutTree lct(n, arr);
    lct.link(1, 2);
    lct.split(1, 2);
    lct.pushup(2);
    cout << lct.tree[2].sum << endl;

    return 0;
}