Problem: Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:

  * for all x <image> the following inequality holds l ≤ x ≤ r; 
  * 1 ≤ |S| ≤ k; 
  * lets denote the i-th element of the set S as si; value <image> must be as small as possible. 



Help Victor find the described set.

Input

The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).

Output

Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.

If there are multiple optimal sets, you can print any of them.

Examples

Input

8 15 3


Output

1
2
10 11


Input

8 30 7


Output

0
5
14 9 28 11 16

Note

Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.math.BigInteger.*;
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import java.util.logging.Level;
import java.util.logging.Logger;

// https://netbeans.org/kb/73/java/editor-codereference_ru.html#display
//<editor-fold defaultstate="collapsed" desc="Main">
public class Main {

    private void run() {
        Locale.setDefault(Locale.US);
        boolean oj = true;
        try {
            oj = System.getProperty("MYLOCAL") == null;
        } catch (Exception e) {
        }

        if (oj) {
            sc = new FastScanner(new InputStreamReader(System.in));
            out = new PrintWriter(new OutputStreamWriter(System.out));
        } else {
            try {
                sc = new FastScanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            } catch (IOException e) {
                MLE();
            }
        }
        Solver s = new Solver();
        s.sc = sc;
        s.out = out;
        s.solve();
        if (!oj) {
            err.println("Time: " + (System.currentTimeMillis() - timeBegin) / 1e3);
            err.printf("Mem: %d\n", (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) >> 20);
        }
        out.flush();
    }

    private void show(int[] arr) {
        for (int v : arr) {
            err.print(" " + v);
        }
        err.println();
    }

    public static void exit() {
        out.flush();
        out.close();
        System.exit(0);
    }

    public static void MLE() {
        int[][] arr = new int[1024 * 1024][];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[1024 * 1024];
        }
    }

    public static void main(String[] args) {
        new Main().run();
    }

    long timeBegin = System.currentTimeMillis();
    static FastScanner sc;
    static PrintWriter out;
    static PrintStream err = System.err;
}
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="FastScanner">
class FastScanner {

    BufferedReader br;
    StringTokenizer st;

    FastScanner(InputStreamReader reader) {
        br = new BufferedReader(reader);
        st = new StringTokenizer("");
    }

    String next() {
        while (!st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException ex) {
                Main.MLE();
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }
}
//</editor-fold>

class Solver {

    FastScanner sc;
    PrintWriter out;
    PrintStream err = System.err;

    long l, r;
    int k;
    long ans = Long.MAX_VALUE;
    long[] vect;
    
    void f( long... arr ){
        long curAns = 0;
        for (long v : arr) curAns ^= v;
        if( ans > curAns ){
            ans = curAns;
            vect = arr;
        }
    }
    
    void solve() {
        l = sc.nextLong();
        r = sc.nextLong();
        k = sc.nextInt();
        
        f( l );
        
        if( 2 <= k ){
            f( l, l+1 );
            if( l+2 <= r )
                f( l+1, l+2 );
        }
        
        
        if( 3 <= k )
        for (int a = 0; a <= 50; a++) {
        for (int b = 0; b <= 50; b++) {
        for (int c = 0; c <= 50; c++) {        
            long x = 0, y = 0, z = 0;
            
            x = add( x, a, 1 );
            x = add( x, b, 1 );
            x = add( x, c, 0 );
            
            y = add( y, a, 1 );
            y = add( y, b, 0 );
            y = add( y, c, 1 );
            
            z = add( z, a, 0 );
            z = add( z, b, 1 );
            z = add( z, c, 1 );
            
            if( l <= z && z < y && y < x && x <= r ){
                f( x, y, z );
            }
        }
        }
        }
        
        if( 4 <= k ){
            f( l, l+1, l+2, l+3 );
            if( l+4 <= r )
                f( l+1, l+2, l+3, l+4 );
        }
        
        out.println(ans);
        out.println(vect.length);
        for (long v : vect) out.print( " " + v );
        out.println();
        
        /////////////////////////////////////////////////
    }        

    long add( long val, int cnt, int bit) {
        for (int iter = 0; iter < cnt; iter++) {
            val = val*2 + bit;
        }
        return val;
    }

}