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 java.io.*;
import java.math.*;
import java.util.*;
import javax.print.attribute.SetOfIntegerSyntax;
 
public class Solution{
    private static InputStream stream;
    private static byte[] buf = new byte[1024];
    private static int curChar;
    private static int numChars;
    private static SpaceCharFilter filter;
    private static PrintWriter pw;
    private static long count = 0,mod=1000000007,max=0;
    private static TreeSet<Integer>ts[]=new TreeSet[200000];
    private static ArrayList<Pair>[] adj;
    
    public static void main(String args[]) throws Exception {
        InputReader(System.in);
        pw = new PrintWriter(System.out); 
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   soln();
                   pw.close();
               } catch(Exception e){
                   e.printStackTrace();
               }
           }
       },"1",1<<26).start();
    }
    //----------------------------------------My Code------------------------------------------------//
    
    
    private static void soln(){
    	 int a = nextInt(), b = nextInt(), x = nextInt();
    	 int n = a + b;
    	 StringBuilder sb = new StringBuilder();
    	 if(b<a) {
	    	 sb.append('0');
	    	 a--;
	    	 for(int i=0;i<x-1;i++) {
	    		 if(i%2==0) {
	    			 sb.append('1');
	    			 b--;
	    		 }else {
	    			 sb.append('0');
	    			 a--;
	    		 } 
	    	 }
    	 }
    	 else {
    		 sb.append('1');
    		 b--;
	    	 for(int i=0;i<x-1;i++) {
	    		 if(i%2==0) {
	    			 sb.append('0');
	    			 a--;
	    		 }else {
	    			 sb.append('1');
	    			 b--;
	    		 } 
	    	 }
    	 }
    	 char last = sb.charAt(sb.length()-1);
    	 if(last=='0') {
    		 for(int i=0;i<a;i++) {
    			 sb.append('0');
    		 }
    		 for(int i=0;i<b;i++) {
    			 sb.append('1');
    		 }
    	 }else {
    		 for(int i=0;i<b;i++) {
    			 sb.append('1');
    		 }
    		 for(int i=0;i<a;i++) {
    			 sb.append('0');
    		 }
    	 }
    	 pw.println(sb.toString());
    }
    
   private static int dijkstra(int root, int dest, int k) {
	   int n = adj.length;
	   PriorityQueue<Pair> neigh = new PriorityQueue<>();
	   //int[] dist = new int[n];
	   Pair[] dist = new Pair[n];
	   for(int i = 0; i < n; i++) dist[i] = new Pair(i,Integer.MAX_VALUE);
	   //Arrays.fill(dist, Integer.MAX_VALUE);
	   dist[root].val = 0;
	   boolean visited[] = new boolean[n];
	   boolean neighboured[] = new  boolean[n];
	   neighboured[root] = true;
	   neigh.add(dist[root]);
	   while(!neigh.isEmpty()) {
		   Pair current = neigh.poll();
		   visited[current.idx] = true;
		   for(Pair neighbour : adj[current.idx]) {
			   if(visited[neighbour.idx]) continue;
			   int decision = ((current.val+neighbour.val)/k)%2;
			   int distance = 0;
			   if(decision == 0 ) {
				   distance = current.val+neighbour.val;
			   }else {
				   distance = current.val+neighbour.val + k - (current.val+neighbour.val)%k;
			   }
			   if(distance < dist[neighbour.idx].val) {
				   dist[neighbour.idx].val = distance;
			   }
			   if(!neighboured[neighbour.idx]) {
				   neigh.add(dist[neighbour.idx]);
				   neighboured[neighbour.idx] = true;
			   }
		   }
	   }
	   return dist[dest].val;
   }
    
	static int ver=-1;
	private static void dfs(int root,LinkedList<Integer>[] adj,boolean[] visited){
		visited[root]=true;
		boolean flag=false;
		for(int x:adj[root]){
			if(!visited[x]){
				count++;
				//pw.println(count+" after incr at node " +root);
				dfs(x,adj,visited);
				flag=true;
				//pw.println(count+" at node "+root);
			}
		}
		if(!flag) {
			long prev=max;
			max=Math.max(count, max);
			if(prev!=max){
				ver=root;
				//arr[root]=(int)Math.max(arr[root], max);
			}
		}
		count--;
		
		visited[root]=false;
	}
	public static int fact(int n){
	    int ans=1;
	    for(int i=1;i<=n;i++) ans=(ans*i)%1000000007;
	    return ans;
	}
	//----------------------------------------THE END----------------------------------------------------------//            
	 
    static class Pair implements Comparable<Pair>{
 
       int idx,val;
        Pair(int idx,int val){
            this.idx=idx;
            this.val = val;
        }
        @Override
        public int compareTo(Pair o) {
           return Integer.compare(this.val, o.val);
            
        }
        //@Override
        public boolean equals(Pair o) {
        	return (this.idx==o.idx && this.val==o.val);
        }
    }
 
    public static long gcd(long x, long y) {
        if (x % y == 0)
            return y;
        else
            return gcd(y, x % y);
    }
    
    private static int BinarySearch(int a[], int low, int high, int target) {
        if (low > high)
            return -1;
        int mid = low + (high - low) / 2;
        if (a[mid] == target)
            return mid;
        if (a[mid] > target)
            high = mid - 1;
        if (a[mid] < target)
            low = mid + 1;
        return BinarySearch(a, low, high, target);
    }
    
    public static String reverseString(String s) {
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        return (sb.toString());
    }
 
    
    
    public static long pow(long n, long p, long m) {
        long result = 1;
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        while (p != 0) {
            if (p % 2 == 1)
                result *= n;
            if (result >= m)
                result %= m;
            p >>= 1;
            n *= n;
            if (n >= m)
                n %= m;
        }
        return result;
    }
 
    public static long pow(long n, long p) {
        long result = 1;
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        while (p != 0) {
            if (p % 2 == 1)
                result *= n;
            p >>= 1;
            n *= n;
        }
        return result;
 
    }
 
     public static int[] radixSort(int[] f) {
        int[] to = new int[f.length];
        {
            int[] b = new int[65537];
            for (int i = 0; i < f.length; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < f.length; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < f.length; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < f.length; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }
 
    public static int nextPowerOf2(final int a) {
        int b = 1;
        while (b < a) {
            b = b << 1;
        }
        return b;
    }
 
    public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
        int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
        int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;
 
        if ((s < 0) != (t < 0))
            return false;
 
        int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
        if (A < 0.0) {
            s = -s;
            t = -t;
            A = -A;
        }
        return s > 0 && t > 0 && (s + t) <= A;
    }
 
    public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
        return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
    }
 
    public static boolean isPrime(int n) {
        // Corner cases
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
 
        // This is checked so that we can skip 
    // middle five numbers in below loop
        if (n % 2 == 0 || n % 3 == 0)
            return false;
 
        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
 
        return true;
    }
 
    //merge Sort
 
    static long sort(int a[])
    {  int n=a.length;
        int b[]=new int[n];    
        return mergeSort(a,b,0,n-1);}
    static long mergeSort(int a[],int b[],long left,long right)
    { long c=0;if(left<right)
     {   long mid=left+(right-left)/2;
         c= mergeSort(a,b,left,mid);
         c+=mergeSort(a,b,mid+1,right);
         c+=merge(a,b,left,mid+1,right); }    
        return c;     }
    static long merge(int a[],int  b[],long left,long mid,long right)
    {long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
    while(i<=(int)mid-1&&j<=(int)right)
    { if(a[i]>a[j]) {b[k++]=a[i++]; }
    else    { b[k++]=a[j++];c+=mid-i;}}
    while (i <= (int)mid - 1)   b[k++] = a[i++]; 
    while (j <= (int)right) b[k++] = a[j++];
    for (i=(int)left; i <= (int)right; i++) 
        a[i] = b[i];  return c;  }
 
    // To Get Input
// Some Buffer Methods
 
    public static void InputReader(InputStream stream1) {
        stream = stream1;
    }
 
    private static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }
 
    private static boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }
 
    private static int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
 
    private static int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
        sgn = -1;
        c = read();
    }
    int res = 0;
    do {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
 
    private static long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
        sgn = -1;
        c = read();
    }
    long res = 0;
    do {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
 
    private static String nextToken() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }
 
    private static String nextLine() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndOfLine(c));
        return res.toString();
    }
 
    private static int[] nextIntArray(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextInt();
        }
        return arr;
    }
 
    private static int[][] next2dArray(int n, int m) {
        int[][] arr = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = nextInt();
            }
        }
        return arr;
    }
 
    private static long[] nextLongArray(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextLong();
        }
        return arr;
    }
 
    private static void pArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            pw.print(arr[i] + " ");
        }
        pw.println();
        return;
    }
 
    private static void pArray(long[] arr) {
        for (int i = 0; i < arr.length; i++) {
            pw.print(arr[i] + " ");
        }
        pw.println();
        return;
    }
 
    private static void pArray(boolean[] arr) {
        for (int i = 0; i < arr.length; i++) {
            pw.print(arr[i] + " ");
        }
        pw.println();
        return;
    }
 
    private static boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
 
    private interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
    
    
}