import java.util.*;

public class Euler167 {
    static List<Long> bruteUlamUntilValue(long a, long b, long minLast) {
        List<Long> seq = new ArrayList<>();
        seq.add(a);
        seq.add(b);
        Map<Long, Integer> reps = new HashMap<>();
        reps.put(a + b, 1);
        long cand = b + 1;
        while (seq.get(seq.size() - 1) < minLast) {
            while (true) {
                int w = reps.getOrDefault(cand, 0);
                if (w == 1)
                    break;
                cand++;
            }
            long next = cand;
            for (long x : seq) {
                if (x == next)
                    continue;
                reps.merge(x + next, 1, (o, n) -> Math.min(o + n, 2));
            }
            seq.add(next);
            cand = next + 1;
        }
        return seq;
    }

    static long kthTerm(int v, long targetK) {
        int gap = v + 1;
        long secondEven = 2L * (v + 1);
        long seedLimit = 2L * gap + 1;
        List<Long> seed = bruteUlamUntilValue(2, v, seedLimit);
        Set<Long> members = new HashSet<>(seed);

        byte[] bits = new byte[gap];
        long[] prefixOnes = new long[gap + 1];
        for (int t = 0; t < gap; t++) {
            bits[t] = members.contains(2L * t + 1) ? (byte) 1 : 0;
            prefixOnes[t + 1] = prefixOnes[t] + bits[t];
        }
        long oddLessThanSecondEven = prefixOnes[gap];
        long secondEvenIndex = 2 + oddLessThanSecondEven;

        // Extend bits via XOR recurrence
        int stateCount = 1 << gap;
        int[] seen = new int[stateCount];
        Arrays.fill(seen, -1);
        int state = 0;
        for (int i = 0; i < gap; i++)
            state = (state << 1) | bits[i];
        seen[state] = 0;
        int lowerMask = gap == 1 ? 0 : (1 << (gap - 1)) - 1;
        List<Byte> bitList = new ArrayList<>();
        for (byte b : bits)
            bitList.add(b);
        List<Long> poList = new ArrayList<>();
        for (long p : prefixOnes)
            poList.add(p);
        int step = 0, cycleStart = -1, cycleEnd = -1;
        while (true) {
            int oldest = (state >> (gap - 1)) & 1, newest = state & 1, nextBit = oldest ^ newest;
            bitList.add((byte) nextBit);
            poList.add(poList.get(poList.size() - 1) + nextBit);
            state = ((state & lowerMask) << 1) | nextBit;
            step++;
            int prev = seen[state];
            if (prev >= 0) {
                cycleStart = prev;
                cycleEnd = step;
                break;
            }
            seen[state] = step;
        }
        long cycleTStart = gap - 1 + cycleStart, cycleTEnd = gap - 1 + cycleEnd;
        long cycleLen = cycleTEnd - cycleTStart;
        long onesBeforeCycle = poList.get((int) (cycleTStart + 1));
        long onesPerCycle = poList.get((int) (cycleTEnd + 1)) - onesBeforeCycle;
        long[] cyclePrefixOnes = new long[(int) (cycleLen + 1)];
        for (long i = 0; i < cycleLen; i++) {
            long t = cycleTStart + 1 + i;
            cyclePrefixOnes[(int) (i + 1)] = cyclePrefixOnes[(int) i] + bitList.get((int) t);
        }

        // kth term
        if (targetK == 1)
            return 2;
        if (targetK == secondEvenIndex)
            return secondEven;
        long oddRank = targetK < secondEvenIndex ? targetK - 1 : targetK - 2;
        // Find t such that prefix_ones[t+1] = oddRank
        long t;
        if (oddRank <= onesBeforeCycle) {
            int lo = 0, hi = (int) (cycleTStart + 1);
            while (lo < hi) {
                int mid = (lo + hi) / 2;
                if (poList.get(mid + 1) >= oddRank)
                    hi = mid;
                else
                    lo = mid + 1;
            }
            t = lo;
        } else {
            long rem = oddRank - onesBeforeCycle;
            long fullCycles = (rem - 1) / onesPerCycle;
            long remInside = rem - fullCycles * onesPerCycle;
            int lo = 0, hi = (int) cycleLen;
            while (lo < hi) {
                int mid = (lo + hi) / 2;
                if (cyclePrefixOnes[mid + 1] >= remInside)
                    hi = mid;
                else
                    lo = mid + 1;
            }
            t = cycleTStart + fullCycles * cycleLen + lo + 1;
        }
        return 2 * t + 1;
    }

    public static void main(String[] args) {
        long targetK = 100000000000L;
        long sum = 0;
        for (int n = 2; n <= 10; n++) {
            int v = 2 * n + 1;
            sum += kthTerm(v, targetK);
        }
        System.out.println(sum);
    }
}