import java.util.*;
import java.math.*;

class Euler261 {
    private static class Options {
        long limit = 10_000_000_000L;
        boolean runCheckpoints = true;
    }

    private static class MEntry {
        int m;
        long q;
        long xMax;
        
        MEntry(int m, long q, long xMax) {
            this.m = m;
            this.q = q;
            this.xMax = xMax;
        }
    }

    private static class PellSolution {
        long x;
        long y;
        
        PellSolution(long x, long y) {
            this.x = x;
            this.y = y;
        }
    }

    private static List<Integer> buildPrimes(int n) {
        int[] spf = new int[n + 1];
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; i++) {
            if (spf[i] == 0) {
                spf[i] = i;
                primes.add(i);
            }
            for (int p : primes) {
                long v = (long)i * p;
                if (v > n || p > spf[i]) break;
                spf[(int)v] = p;
            }
        }
        return primes;
    }

    private static long[] squarefreeAndSquarePart(long n, List<Integer> primes) {
        long s = 1;
        long q = 1;
        long x = n;
        for (int p : primes) {
            long pp = p;
            if (pp * pp > x) break;
            if (x % pp != 0) continue;
            int e = 0;
            while (x % pp == 0) {
                x /= pp;
                e++;
            }
            if ((e & 1) != 0) s *= pp;
            for (int i = 0; i < e/2; i++) q *= pp;
        }
        if (x > 1) s *= x;
        return new long[]{s, q};
    }

    private static long floorSqrtU64(long x) {
        long r = (long)Math.sqrt((double)x);
        while ((r + 1) * (r + 1) <= x) r++;
        while (r * r > x) r--;
        return r;
    }

    private static long[] findFundamentalPellLimited(long s, long xLimit) {
        long a0 = floorSqrtU64(s);
        if (a0 * a0 == s) return null;
        
        long m = 0;
        long d = 1;
        long a = a0;
        
        long pPrev2 = 0;
        long pPrev1 = 1;
        long qPrev2 = 1;
        long qPrev1 = 0;
        
        for (int iter = 0; iter < 2_000_000; iter++) {
            long p = a * pPrev1 + pPrev2;
            long q = a * qPrev1 + qPrev2;
            
            long diff = p * p - s * q * q;
            if (diff == 1 && p > 1 && p <= xLimit) {
                return new long[]{p, q};
            }
            
            if (p > xLimit) return null;
            
            pPrev2 = pPrev1;
            pPrev1 = p;
            qPrev2 = qPrev1;
            qPrev1 = q;
            
            m = d * a - m;
            d = (s - m * m) / d;
            a = (a0 + m) / d;
        }
        return null;
    }

    private static List<PellSolution> pellSolutionsUpTo(long s, long xLimit) {
        long[] fundamental = findFundamentalPellLimited(s, xLimit);
        if (fundamental == null) return new ArrayList<>();
        
        long x1 = fundamental[0];
        long y1 = fundamental[1];
        
        List<PellSolution> solutions = new ArrayList<>();
        long x = x1;
        long y = y1;
        
        while (x <= xLimit) {
            solutions.add(new PellSolution(x, y));
            BigInteger nx = BigInteger.valueOf(x1).multiply(BigInteger.valueOf(x))
                          .add(BigInteger.valueOf(s).multiply(BigInteger.valueOf(y1)).multiply(BigInteger.valueOf(y)));
            BigInteger ny = BigInteger.valueOf(x1).multiply(BigInteger.valueOf(y))
                          .add(BigInteger.valueOf(y1).multiply(BigInteger.valueOf(x)));
            if (nx.compareTo(BigInteger.valueOf(xLimit)) > 0) break;
            x = nx.longValue();
            y = ny.longValue();
        }
        return solutions;
    }

    private static List<Long> generateSquarePivots(long limit) {
        int mMax = (int)((Math.sqrt(2.0 * limit + 1.0) - 1.0) / 2.0);
        List<Integer> primes = buildPrimes(mMax + 2);
        Map<Long, List<MEntry>> grouped = new HashMap<>();
        
        for (int m = 1; m <= mMax; m++) {
            long n = (long)m * (m + 1);
            long[] sqParts = squarefreeAndSquarePart(n, primes);
            long s = sqParts[0];
            long q = sqParts[1];
            long xMax = (2 * limit - m) / m;
            grouped.computeIfAbsent(s, k -> new ArrayList<>()).add(new MEntry(m, q, xMax));
        }
        
        List<Long> pivots = new ArrayList<>();
        for (Map.Entry<Long, List<MEntry>> entry : grouped.entrySet()) {
            long s = entry.getKey();
            List<MEntry> entries = entry.getValue();
            
            long xMax = 0;
            for (MEntry e : entries) {
                xMax = Math.max(xMax, e.xMax);
            }
            
            List<PellSolution> sols = pellSolutionsUpTo(s, xMax);
            if (sols.isEmpty()) continue;
            
            for (MEntry e : entries) {
                long minD = 2L * e.m + 1;
                long m128 = e.m;
                long qs128 = e.q * s;
                
                for (PellSolution sol : sols) {
                    if (sol.x < minD) continue;
                    if ((sol.x & 1L) == 0L) continue;
                    
                    long numerator = m128 * sol.x + qs128 * sol.y + m128;
                    if ((numerator & 1L) != 0L) continue;
                    
                    long k = numerator / 2;
                    if (k > limit) continue;
                    if (k > 0) pivots.add(k);
                }
            }
        }
        
        Collections.sort(pivots);
        return new ArrayList<>(new LinkedHashSet<>(pivots));
    }

    private static long solve(long limit) {
        List<Long> pivots = generateSquarePivots(limit);
        long sum = 0;
        for (Long k : pivots) {
            sum += k;
        }
        return sum;
    }

    private static List<Long> brutePivots(int limit) {
        List<Long> pivots = new ArrayList<>();
        for (int k = 1; k <= limit; k++) {
            boolean ok = false;
            for (int m = 1; m < k && !ok; m++) {
                long lhs = (long)(m + 1) * k * (k - m);
                if (lhs % m != 0) continue;
                long c = lhs / m;
                long d = (long)(m + 1) * (m + 1) + 4 * c;
                long s = (long)Math.sqrt((double)d);
                long root = s;
                while ((root + 1) * (root + 1) <= d) root++;
                while (root * root > d) root--;
                if (root * root != d) continue;
                long numer = -(m + 1) + root;
                if ((numer & 1L) != 0) continue;
                long n = numer / 2;
                if (n >= k) ok = true;
            }
            if (ok) pivots.add((long)k);
        }
        return pivots;
    }

    private static boolean runCheckpoints() {
        List<Long> fastSmall = generateSquarePivots(5000);
        List<Long> bruteSmall = brutePivots(5000);
        if (!fastSmall.equals(bruteSmall)) {
            System.err.println("Checkpoint failed for limit=5000");
            return false;
        }
        
        List<Long> sample = generateSquarePivots(120);
        long[] required = {4, 21, 24, 110};
        for (long x : required) {
            if (!sample.contains(x)) {
                System.err.println("Checkpoint failed: missing sample pivot " + x);
                return false;
            }
        }
        return true;
    }

    private static Options parseArguments(String[] args) {
        Options options = new Options();
        for (String arg : args) {
            if (arg.equals("--skip-checkpoints")) {
                options.runCheckpoints = false;
            } else if (arg.startsWith("--limit=")) {
                try {
                    options.limit = Long.parseLong(arg.substring(8));
                } catch (NumberFormatException e) {
                    System.err.println("Unknown argument: " + arg);
                    return null;
                }
            } else {
                System.err.println("Unknown argument: " + arg);
                return null;
            }
        }
        if (options.limit < 1) return null;
        return options;
    }

    public static void main(String[] args) {
        Options options = parseArguments(args);
        if (options == null) {
            System.exit(1);
            return;
        }
        if (options.runCheckpoints && !runCheckpoints()) {
            System.exit(2);
            return;
        }
        System.out.println(solve(options.limit));
    }
}