You are given three integers a, b and x. Your task is to construct a binary string s of length n = a + b such that there are exactly a zeroes, exactly b ones and exactly x indices i (where 1 ≤ i < n) such that s_i ≠ s_{i + 1}. It is guaranteed that the answer always exists.

For example, for the string "01010" there are four indices i such that 1 ≤ i < n and s_i ≠ s_{i + 1} (i = 1, 2, 3, 4). For the string "111001" there are two such indices i (i = 3, 5).

Recall that binary string is a non-empty sequence of characters where each character is either 0 or 1.

Input

The first line of the input contains three integers a, b and x (1 ≤ a, b ≤ 100, 1 ≤ x < a + b).

Output

Print only one string s, where s is any binary string satisfying conditions described above. It is guaranteed that the answer always exists.

Examples

Input

2 2 1


Output

1100


Input

3 3 3


Output

101100


Input

5 3 6


Output

01010100

Note

All possible answers for the first example: 

  * 1100; 
  * 0011. 



All possible answers for the second example: 

  * 110100; 
  * 101100; 
  * 110010; 
  * 100110; 
  * 011001; 
  * 001101; 
  * 010011; 
  * 001011. 
import sun.security.krb5.internal.rcache.DflCache;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * @author Vikash Kumar(vikashkumarbissu)
 * NIT Silchar
 */

public class Main {
    public static void main(String[] args)throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }
    static class Task {
        static int mod = (int) 1e9 + 7;

        public static void solve(int testNumber, FastReader in, PrintWriter out) throws IOException {
            int a = in.nextInt();
            int b = in.nextInt();
            int x = in.nextInt();
            StringBuilder sub = new StringBuilder();
            if (x % 2 == 0) {
                if (a > b) {
                    int mid = x / 2;
                    int i = 1;
                    while (i <= mid) {
                        sub.append("01");
                        i++;
                    }
                    int rest_b = b - mid;
                    //out.println(rest_b);
                    i = 1;
                    while (i <= rest_b) {
                        sub.append("1");
                        i++;
                        //out.println(sub);
                    }
                    int rest_a = a - mid;
                    i = 1;
                    //out.println(rest_a+" "+i);
                    while (i <= rest_a) {
                        sub.append("0");
                        i++;
                        //out.println(sub);
                    }
                } else {
                    int mid = x / 2;
                    int i = 1;
                    while (i <= mid) {
                        sub.append("10");
                        i++;
                    }
                    int rest_a = a - mid;
                    //out.println(rest_a);
                    i = 1;
                    while (i <= rest_a) {
                        sub.append("0");
                        i++;
                        //out.println(sub);
                    }
                    int rest_b = b - mid;
                    //out.println(rest_b);
                    i = 1;
                    while (i <= rest_b) {
                        sub.append("1");
                        i++;
                        //out.println(sub);
                    }
                }
            } else {
                if (a > b) {
                    int mid = x / 2;
                    int i = 1;
                    while (i <= mid) {
                        sub.append("01");
                        i++;
                    }
                    int rest_a = a - mid;
                    i = 1;
                    while (i <= rest_a) {
                        sub.append("0");
                        i++;
                        //out.println(sub);
                    }
                    int rest_b = b - mid;
                    i = 1;
                    while (i <= rest_b) {
                        sub.append("1");
                        i++;
                        //out.println(sub);
                    }
                } else {
                    int mid = x / 2;
                    int i = 1;
                    while (i <= mid) {
                        sub.append("10");
                        i++;
                    }
                    int rest_b = b - mid;
                    i = 1;
                    while (i <= rest_b) {
                        sub.append("1");
                        i++;
                    }
                    int rest_a = a - mid;
                    i = 1;
                    while (i <= rest_a) {
                        sub.append("0");
                        i++;
                    }
                }
            }
            out.println(sub);
            out.flush();
        }

        static class index{
            int l, r;

            public index(int l, int r) {
                this.l = l;
                this.r = r;
            }
            public boolean equals(Object o) {
                index ind = (index) o;
                return ind.l == this.l && ind.r == this.r;
            }

            public int hashCode() {
                return (int)(((l*2500L*2500L)+(l*2500L))%1000000007);
            }
        }

//        private static int gcd(int a, int b) {
//            if (a < b)
//                return gcd(b, a);
//            if (b == 0)
//                return a;
//            return gcd(b, a % b);
//        }

//        public static indexing[] sort(indexing[] input){
//
//            // Largest place for a 32-bit int is the 1 billion's place
//            for(int place=1; place <= 1000000000; place *= 10){
//                // Use counting sort at each digit's place
//                input = countingSort(input, place);
//            }
//
//            return input;
//        }
//
//        private static indexing[] countingSort(indexing[] input, int place){
//            indexing[] out = new indexing[input.length];
//
//            int[] count = new int[10];
//
//            for(int i=0; i < input.length; i++){
//                int digit = getDigit(input[i].num, place);
//                count[digit] += 1;
//            }
//
//            for(int i=1; i < count.length; i++){
//                count[i] += count[i-1];
//            }
//
//            for(int i = input.length-1; i >= 0; i--){
//                int digit = getDigit(input[i].num, place);
//
//                out[count[digit] - 1] = new indexing(input[i].num, input[i].value);
//                count[digit]--;
//            }
//
//            return out;
//
//        }
//
//        private static int getDigit(int value, int digitPlace){
//            return ((value/digitPlace ) % 10);
//        }
//
//        static class indexing{
//            int num;StringBuilder value;
//
//            public indexing(int num, StringBuilder value) {
//                this.num = num;
//                this.value = value;
//            }
//        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader(InputStream is) {
            br = new BufferedReader(new
                    InputStreamReader(is));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

    }
}