Problem: Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.

Input

The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.

Output

First print a single integer k — the number of tables with exactly x distinct squares inside.

Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.

Examples

Input

26


Output

6
1 26
2 9
3 5
5 3
9 2
26 1


Input

2


Output

2
1 2
2 1


Input

8


Output

4
1 8
2 3
3 2
8 1

Note

In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.

<image>

In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.

<image>

Solution (in JAVA):

Solution:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

/**
 * Nov 20, 2015 | 5:32:18 PM
 * <pre>
 * <u>Description</u>
 *
 * </pre>
 *
 * @author Essiennta Emmanuel (colourfulemmanuel@gmail.com)
 */
public class ProblemD{

    int sumNsquare(int n){
        return n * (n + 1) * (2 * n + 1) / 6;
    }

    int sumN(int n){
        return n * (n + 1) / 2;
    }

    int count(int m, int n){
        return Math.min(m, n) * (m + 1) * (n + 1) + sumNsquare(Math.min(m, n)) - (2 + m + n) * sumN(Math.min(m, n));
    }

    List<long[]> solve(long x){
        List<long[]> list = new ArrayList<>();
        for (long i = 1; i <= 2 * (int)1e6; i++) {
            long num = 6L * x - i * (i + 1) * (2 * i + 1) - 6 * i * (i + 1) + 3 * i * (i + 1) * (i + 2);
            long den = 6L * i * (i + 1) - 3 * i * (i + 1);
            if (num % den != 0)
                continue;
            long t = num / den;
            if (t < i)
                continue;
            list.add(new long[]{i, t});
            if (i != t)
                list.add(new long[]{t, i});
        }
        Collections.sort(list, new Comparator<long[]>(){

            @Override
            public int compare(long[] o1, long[] o2){
                return Long.compare(o1[0], o2[0]);
            }
        });
        return list;
    }
    
    List<Long> l1 = new ArrayList<>();
    List<Long> l2 = new ArrayList<>();
    Integer[] solve2(long x){
        for (long i = 1; i <= 2 * (int)1e6; i++) {
            long num = 6L * x - i * (i + 1) * (2 * i + 1) - 6 * i * (i + 1) + 3 * i * (i + 1) * (i + 2);
            long den = 6L * i * (i + 1) - 3 * i * (i + 1);
            if (num % den != 0)
                continue;
            long t = num / den;
            if (t < i)
                continue;
            l1.add(i);
            l2.add(t);
            if (i != t){
                l1.add(t);
                l2.add(i);
            }
        }
        
        Integer[] ind = new Integer[l1.size()];
        for (int i = 0; i < ind.length; i++)
            ind[i] = i;
        Arrays.sort(ind, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2){
                return Long.compare(l1.get(o1), l1.get(o2));
            }
        });
        return ind;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        final ProblemD problemD = new ProblemD();
        Integer[] solve = problemD.solve2(sc.nextLong());
        System.out.println(solve.length);
        for (int i : solve)
            System.out.printf("%d %d%n", problemD.l1.get(i), problemD.l2.get(i));
        sc.close();
    }
}