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.util.*;
  
 
  
        public class Codeforces {
    	
    		   public static long log2(long x)
    			{
    				long p=1;
    				long ans=0;
    				while(x>=p)
    				{
    					p*=2;
    					ans++;
    				}
    				return ans-1;
    			}
    		   
    		   
    		   public static void extendedgcd(int a, int b)
    		   {
    			   x=0;
    			   y=0;
    			   gc=0;
    			   xgcd(a,b);
    			   pw.println(a+"*"+x+" + "+b+"*"+y+" = "+gc);
    			   
    		   }
    		   
    		   
    		   public static long modex(long a, long b, long c)
    		   {
    			   if(b==0)
    				   return 1;
    			   else if(b==1)
    				   return a%c;
    			   else if(b%2==0)
    			   {
    				   	return modex((a*a)%c,b/2,c);
    			   }
    			   else
    			   {
    				   return (a*modex((a*a)%c,b/2,c))%c;
    				   
    			   }
    			   
    			   
    		   }
    		   
    		   
    		   public static void xgcd(int a, int b)
    		   {
    			   
    			   if(b==0)
    			   {
    				   x=1;
    				   y=0;
    				   gc=a;
    				   
    				   
    			   }
    			   else
    			   {
    				   xgcd(b,a%b);
    				   int temp = x;
    				   x=y;
    				   y = temp - ((a/b)*y);
    				   
    			   }
    		   }
    		   
    		   public static long gcd(long a, long b)
    		   {
    			   if(b==0)return a;
    			   else return gcd(b,a%b);
    			   
    		   }
    		   
    		   static int x,y,gc;
    		   
    		  
    		
    		   
    		   static HashSet<Character> set;
    		   
    		   
    		   
    		   public static long expmod(long a, long b, long mod)
    		   {
    			   if(b==0)return 1;
    			   if(b==1)return a;
    			   
    			   if(b%2==0)
    			   {
    				   return ((expmod(a,b/2,mod)%mod)*(expmod(a,b/2,mod)%mod))%mod;
    			   }
    			   else
    			   {
    				   return ((a%mod)*(expmod(a,b/2,mod)%mod)*(expmod(a,b/2,mod)%mod))%mod;
    			   }
    		   }
    		   
    		   static class Comp implements Comparator<Point>
    		   {

				@Override
				public int compare(Point arg0, Point arg1) {
					
					if(arg0.x>arg1.x)return 1;
					if(arg0.x<arg1.x)return -1;
					return 0;
				}
    			   
    		   }
    		   
    		   
    		   static class STComp implements Comparator<Integer>
    		   {

				@Override
				public int compare(Integer arg0, Integer arg1) {
					
					return arg0.compareTo(arg1); 
				}
    			   
    		   }
    		   
    		   static class Point
    		   {
    			   int x,y,ind;
    			   
    			    public Point(int a, int b)
    			    {
    			    	x=a;
    			    	y=b;
    			    	ind=0;
    			    }
    			   
    			    
    		   }
    		   
    		 
    		   
    		  
    		   
    		   public static boolean issub(String s1, String s2)
    		   {
    			   if(s1.length()>s2.length())
    			   return false;
    			   
    			   int l1 = s1.length();
    			   int l2 = s2.length();
    			   
    			   
    			   for(int i=0;i<=l2-l1;i++)
    			   {
    				   String sub = s2.substring(i, i+l1);
    				   if(s1.equals(sub))return true;
    			   }
    			   
    			   return false;
    		   }
    		   
    		   
    		   
    		   public static String enc(String s, int n)
    		   {
    			   String s1 = s.substring(0,n);
    			   String s2 = s.substring(n, s.length());
    			   
    			  String re="";
    			  for(int i=s1.length()-1;i>=0;i--)re+=s1.charAt(i);
    			  
    			  return re+s2;
    			   
    			   
    			   
    		   }
    		 
    		   
    		   
    		   static int vis[];
    		   
    		   public static void dfs(int x)
    		   {
    			   vis[x]=1;
    			   
    			   ArrayList<Integer> li = adj[x];
    			   
    			   for(int ch:li)
    			   {
    				   
    				   if(vis[ch]==0)dfs(ch);
    				   
    			   }
    			   
    		   }
    		   /*
    		   public static void dfsm(int x, HashSet<Integer> set)
    		   {
    			   vis2[x]=1;
    			   
    			   ArrayList<Integer> li = adj[x];
    			   
    			   for(int ch:li)
    			   {
    				   //if(!set.contains(ch))continue;
    				   if(vis2[ch]==0)dfsm(ch,set);
    				   
    			   }
    			   
    		   }
    		   */
    		   
    		  
    		
    		   public static void countPaths(int s, int d, ArrayList<Integer> pa)
    		   {
    			   
    			   vis2[s]=1;
    			   if(s==d)
    			   {
    				   pa.add(s);
    				 //  paths[ct] = new ArrayList<Integer>(pa);
    				   ct++;
    			   }
    			   else
    			   {
    				   ArrayList<Integer> li = adj[s];
    				   pa.add(s);
    				   
    				   for(int ad: li)
    				   {
    					   if(vis2[ad]==0)countPaths(ad,d,pa);
    				   }
    				   
    				   
    			   }
    			   
    			   if(pa.size()>1)pa.remove(pa.size()-1);
    			   vis2[s]=0;
    			   return ;
    		   }
    		  
    		   
    		   
    		   public static boolean dif(String s1, String s2)
    		   {
    			   int ct=0;
    			   if(s1.length()!=s2.length())return false;
    			   for(int i=0;i<s1.length();i++)
    			   {
    				   if(s1.charAt(i)!=s2.charAt(i))ct++;
    				   
    			   }
    			   
    			   if(ct==1)return true;
    			   else return false;
    			   
    			   
    		   }
    		   
    		   
    		   
    		   
    		   static void add(int arr[], int N, int lo,
                       int hi, int val)
    		   {
							    arr[lo] += val;
							    if (hi != N - 1)
							       arr[hi + 1] -= val;
    		   }
 
// Utility method to get actual array from 
// operation array
static void updateArray(int arr[], int N)
{
    // convert array into prefix sum array
    for (int i = 1; i < N; i++)
        arr[i] += arr[i - 1];
}
  
// method to print final updated array
static void printArr(int arr[], int N)
{
    updateArray(arr, N);
    for (int i = 0; i < N; i++)
        System.out.print(""+arr[i]+" ");
    System.out.print("\n");
}
  
    		   
  
    		  static int cyc;
    		   
    		   
    		  
    		  public static void dfsmod(int v, HashSet<Integer> set)
    		  {
    			  vis2[v]=1;
    			  
    			  ArrayList<Integer> li = adj[v];
    			  
    			  set.add(v);
    			  
    			  for(int ch: li)
    			  {
    				  if(set.contains(ch))
    				  {
    					  cyc=1;
    					  pw.println("** "+ch+" "+v);
    				  }
    				  if(vis2[ch]==0)dfsmod(ch,set);
    				  
    			  }
    			  
    			  set.remove(v);
    			  
    			  
    		  }
    		  
    		  
    		  	public static boolean isps(int x)
    		  	{
    		  		int sq = (int)Math.sqrt(x);
    		  		
    		  		return sq>0&&sq*sq==x;
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  	}
    		  
    		  	 public static void combinations(String suffix,String prefix)
    		  	 {
    		         if(prefix.length()<0)return;
    		         pw.println(suffix);
    		        	 
    		        	 
    		         for(int i=0;i<prefix.length();i++)
    		          combinations(suffix+prefix.charAt(i),prefix.substring(i+1,prefix.length()));
    		         
    		     }
    		  	
    		  	
    		  	 
    		
    		  	 
    		  	 
    		  	 public static void topo(int x)
    		  	 {
    		  		 vis2[x]=1;
    		  		// pw.println("vis "+x);
    		  		 ArrayList<Integer> li = adj[x];
    		  		// pw.println(x+" has siz "+li.size());
    		  		// Integer i = x;
    		  		 for(int ch: li)
    		  		 {
    		  			
    		  			 if(vis2[ch]==0)
    		  				 {topo(ch);
    		  				//pw.println(x+" "+ch);
    		  				 }
    		  		 }
    		  		 
    		  		 st.push(x);
    		  		 //pw.println(i+" pushed");
    		  	 }
    		  	 
    		  	 
    	  		   

    		 	static  ArrayList<Integer>[] adj;
    		 	static int[] vis2;
    		 	static int ct;

    		     public static void ch(Stack<Integer> s)
    		     {
    		    	 s.push(4);
    		    	 return;
    		     }
    		     
    		     static Stack<Integer> st;
    		     
    		     
    		     static class PQnode implements Comparable<PQnode>
    		     {
    		    	 int value;
    		    	 int distance;
    		    	 
    		    	 public PQnode(int x, int y)
    		    	 {
    		    		 value=x;
    		    		 distance=y;
    		    	 }

					@Override
					public int compareTo(PQnode o) {
					return Integer.compare(this.distance, o.distance);
						
					
					
					}
					
					
					  @Override
		    		    public  boolean equals(Object o)
		    		    {
		    		    	if(o==this)return true;
		    		    	
		    		    	if(!(o instanceof PQnode))
		    		    	{
		    		    		return false;
		    		    	}
		    		    	
		    		    	PQnode node = (PQnode) o;
		    		    	
		    		    	return value==node.value&&distance==node.distance;
		    		    	
		    		    }
    		     }
    		  
    		  
    		     static class Compq implements Comparator<PQnode>
    		     {

					
					public int compare(PQnode arg0, PQnode arg1) {
						
						if(arg0.distance>arg1.distance)return 1;
						if(arg0.distance<arg1.distance)return -1;
						return 0;
					}
    		    	 
    		    	 
    		    	 
    		     }
    		     
    		     public static void printpa(int pa[],int x)
    		     {
    		    	 if(pa[x]==-1)
    		    		 
    		    		 pw.println(x);
    		    	 else
    		    	 {
    		    		 printpa(pa, pa[x]);
    		    		 pw.println(x);
    		    	 }
    		     }
    		     
    		     
    		     static class Node
    		     {
    		    	 int data;
    		    	 Node next;
    		    	 
    		    	 public Node(int x)
    		    	 {
    		    		 data =x;
    		    		 next=null;
    		    	 }
    		     }
    		     
    		     static Node he;
    		     static Node rev(Node n)
    		     {
    		    	 if(n.next==null)
    		    	 {
    		    		he=n;
    		    		return n;
    		    		 
    		    	 }
    		    	 else
    		    	 {
    		    		 Node rt = rev(n.next);
    		    		 rt.next=n;
    		    		 return n;
    		    	 }
    		    	 
    		     }
    		     
    		     
    		     public static void main(String[] args) 
    	   {
    		  		
    		    	 
    		    	 int a = sc.nextInt();
     		  		int b = sc.nextInt();
     		  		
     		  		int x = sc.nextInt();
     		  		
     		  		
     		  		int ini=(a>b)?0:1;
     		  		int inif=ini;
     		  		String ans= Integer.toString(ini);
     		  		
     		  		if(ini==1)b--;
     		  		else a--;
     		  		
     		  		
     		  		for(int i=0;i<x-1;i++)
     		  		{
     		  			if(ini==1)
     		  			{
     		  				if(a>0)
     		  				{
     		  				ans+='0';
     		  				a--;
     		  				ini=0;
     		  				}
     		  			}
     		  			else
     		  			{	if(b>0)
     		  				{
     		  				ans+='1';
     		  				b--;
     		  				ini=1;
     		  				}
     		  			}
     		  		}
     		  		
     		  		String r1="";
     		  		String r2="";
     		  		
     		  		while(a-->0)r1+='0';
     		  		while(b-->0)r2+='1';
     		  		
     		  		//pw.println("ini "+ans+" "+ini);
     		  		
     		  		if(inif==ini)
     		  		{
     		  			
     		  			if(inif==0)
     		  			{
     		  			
     		  				ans=ans+r2;
     		  				ans = r1+ans;
     		  			}
     		  			else
     		  			{
     		  				ans=ans+r1;
     		  				ans=r2+ans;
     		  				
     		  			}
     		  			
     		  		}
     		  		else
     		  		{
     		  			if(inif==0)//inif=1
     		  			{
     		  				if(r1==""||r2=="")
     		  				{
     		  					
     		  					if(r1=="")
     		  					{
     		  						ans = r2+ans;
     		  					}
     		  					else
     		  					{
     		  						ans = ans+r1;
     		  					}
     		  				}
     		  				else
     		  				{
     		  					
     		  					String rf = r2+r1;
     		  					ans=rf+ans;
     		  					
     		  				}
     		  				
     		  				
     		  			}
     		  			else
     		  			{	//pw.println("xx");
     		  				// 1...0
     		  				
     		  				if(r1==""||r2=="")
     		  				{
     		  					
     		  					if(r1=="")
     		  					{
     		  						ans = ans+r2;
     		  					}
     		  					else
     		  					{
     		  						ans=r1+ans;
     		  					}
     		  				}
     		  				else
     		  				{
     		  					String rf = r1+r2;
     		  					ans = rf+ans;
     		  					
     		  				}
     		  				
     		  				
     		  				
     		  				
     		  			}
     		  			
     		  			
     		  			
     		  		}
     		  		
     		  		
     		  		
     		    	pw.println(ans);
    		    	 
    		    	 /*int n  =sc.nextInt();
    		  		int k = sc.nextInt();
    		  		
    		  		int arr[] = new int[n];
    		  		
    		  		for(int i=0;i<n;i++)arr[i]=sc.nextInt();
    		  		
    		  		int pref[] =  new int[n];
    		  		
    		  		for(int i=0;i<n;i++)
    		  		{
    		  			if(i==0)
    		  			{
    		  				pref[i]=arr[i];
    		  			}
    		  			else
    		  			{
    		  				pref[i]=pref[i-1]+arr[i];
    		  			}
    		  		}
    		  				
    		  		double ans = Float.MIN_VALUE;
    		  		
    		  		
    		  		
    		  		for(int i=k;i<=n;i++)
    		  		{
    		  			
    		  			int p1 = 0;
    		  			int p2= i-1;
    		  			
    		  			while(p2<=n)
    		  			{
    		  				//pw.println("calc "+p1+" "+p2);
    		  				double rsum = (p1==0)?pref[p2]:pref[p2]-pref[p1-1];
    		  				double avg = rsum/i;
    		  				//pw.println(i);
    		  				ans = Math.max(ans, avg);
    		  				p1++;
    		  				p2++;
    		  				//pw.println("********");
    		  				if(p2==n)break;
    		  			}
    		  			
    		  		}
    		    	 
    		  		pw.println(ans);
    		    	 */
    		    	 
    		    	 /*
    		    	 */
    		    	
    		    	
    		    	
    		    	/* 
    		    	Node n1 = new Node(1);
    		    	Node n2 = new Node(2);
    		    	Node n3 = new Node(3);
    		    	n1.next=n2;
    		    	n2.next=n3;
    		    	n3.next=null;
    		    	
    		    	rev(n1);
    		    	
    		    	while(he!=null)
    		    	{
    		    		pw.println(he.data);
    		    		he=he.next;
    		    	}
    		    	 */
    		    	 /* 
    		    	int n = sc.nextInt();
    		  		 
    		  		int x = sc.nextInt();
    		  		int y = sc.nextInt();
    		  		
    		  		String st = sc.nextLine();
    		  		int ind[] = new int[n];
    		  		int indct=0;
    		  		for(int i=0;i<st.length();i++)
    		  		{
    		  			if(st.charAt(i)=='1')
    		  			{
    		  				ind[indct++]=i;
    		  			}
    		  			
    		  		}
    		  		
    		  		
    		  		int r=0;
    		  		if(indct==0||indct==1)
    		  		{
    		  			if(indct==0)
    		  			{
    		  				pw.println(y);
    		  				pw.close();
    		  				return;
    		  			}
    		  			else
    		  			{
    		  				r=1;
    		  			}
    		  		}
    		  		
    		  		
    		  		else
    		  		{
    		  		
    		  		for(int i=0;i<indct-1;i++)
    		  		{
    		  			if(ind[i+1]-ind[i]>1)r++;
    		  		}
    		  		
    		  		if(r==0)
    		  		{
    		  			if(r==0)
    		  			{
    		  				pw.println(0);
    		  				pw.close();
    		  				return;
    		  			}
    		  			
    		  		}
    		  		
    		  		r++;
    		  		
    		  		}
    		  		
    		  		
    		  		//pw.println("r "+r);
    		  		
    		  		
    		  		long ans = Long.MAX_VALUE;
    		  		
    		  		for(int rev=0;rev<=r;rev++)
    		  		{
    		  			long left = r-rev;
    		  			long p = (left+1)*y + x*rev;
    		  			//pw.println(" p "+p);
    		  			ans = Math.min(p, ans);
    		  		}
    		  		
    		  		
    		  		pw.println(ans);
    		  		 */
    		  			
    		  				
    		  		 
    		  		 /*PriorityQueue<PQnode> pq = new PriorityQueue<PQnode>();
    		  		
    		  		 pw.println(pq.size());
    		  		 
    		  		 pq.add(new PQnode(1,2));
    		  		 pq.add(new PQnode(3,4));
    		  		 
    		  		 pw.println(pq.size());
    		  		pq.remove(new PQnode(1,2));
    		  		 pw.println(pq.size());
    		  		 
    		  		 
    		  		 
    		  		 int parent[] = new int[4];
    		  		 Arrays.fill(parent, -1);
    		  		 ArrayList<Point> adj[] = new ArrayList[4];
    		  		 
    		  		 for(int i=0;i<4;i++)adj[i] = new ArrayList<Point>();
    		  		 
    		  		 adj[0].add(new Point(1,10));
    		  		 adj[0].add(new Point(2,20));
    		  		 
    		  		 adj[1].add(new Point(0,10));
    		  		adj[1].add(new Point(2,5));
    		  		adj[1].add(new Point(3,16));
    		  		
    		  		adj[2].add(new Point(0,20));
    		  		adj[2].add(new Point(1,5));
    		  		adj[2].add(new Point(3,20));
    		  		
    		  		adj[3].add(new Point(1,16));
    		  		adj[3].add(new Point(2,20));
    		  		 
    		  		 
    		  		 
    		  		 PriorityQueue<PQnode> pq = new PriorityQueue<PQnode>(new Compq());
    		  		 HashSet<Integer> pres = new HashSet<Integer>();
    		  		 
    		  		 int[] dist = new int[4];
    		  		 
    		  		 for(int i=0;i<4;i++)
    		  		 {
    		  			 if(i==0)
    		  			 {
    		  				pq.add(new PQnode(i,0)); 
    		  				dist[i]=0;
    		  			 }
    		  			 else
    		  			 {
    		  				 pq.add(new PQnode(i,Integer.MAX_VALUE));
    		  				 dist[i]=Integer.MAX_VALUE;
    		  			 }
    		  			 pres.add(i);
    		  			 
    		  		 }
    		  		 
    		  		 
    		  		 while(!pq.isEmpty())
    		  		 {
    		  			 PQnode pop = pq.poll();
    		  			 pres.remove(pop.value);
    		  			// pw.println(pop.value+" "+pop.distance);
    		  			 dist[pop.value]=pop.distance;
    		  			 for(Point p: adj[pop.value])
    		  			 {
    		  				 if(pres.contains(p.x))
    		  				 {
    		  					 if(p.y+dist[pop.value]<dist[p.x])
    		  					 {
    		  						 pw.println("ha");
    		  						
    		  						 pq.remove(new PQnode(p.x,dist[p.x]));
    		  						 dist[p.x]=p.y+dist[pop.value];
    		  						 pq.add(new PQnode(p.x,p.y+dist[pop.value]));
    		  						 parent[p.x]=pop.value;
    		  					 }
    		  				 }
    		  			 }
    		  			 
    		  		 }
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 for(int i=0;i<4;i++)pw.print(dist[i]+" ");
    		  		pw.println();
    		  		 printpa(parent, 3	);
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 Dijkstra over.
    		  		 */
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 /*
    		  		st = new Stack<Integer>();
    		  		 
    			 
    			  cyc=0;
       			adj = new ArrayList[4];
       			vis2 = new int[4];
       			
       			Arrays.fill(vis2, 0);
       			for(int i=0;i<4;i++)adj[i] = new ArrayList<Integer>();
       			   
       			
       			adj[0].add(1);
       			adj[0].add(2);
       			adj[0].add(3);
       			
       			adj[1].add(3);
       			
       			//adj[2].add(0);
       			adj[2].add(1);
    			   //adj[3].add(2);
    			   
       			st = new Stack<Integer>();
    			
       			topo(0);
    			   
    			 while(!st.isEmpty())pw.println(st.pop());
    			 */
    				 
    			/*
    			int n = sc.nextInt();
    			
    			int arr[] = new int[n];
    			
    			for(int i=0;i<n;i++)arr[i]=sc.nextInt();
    			
    			long ansg =0,ansv = Long.MAX_VALUE; 
    			
    			int arr2[] = new int[n];
    			for(int i=0;i<n;i++)arr2[i]=arr[i]-i;
    		
    			for(int i=0;i<n;i++)
    			{
    				int x = arr2[i];
    				
    				if(x<=0)
    				{
    					
    					if(i<ansv)
    					{
    						
    						ansg=i;
    						ansv=i;
    					}
    				}
    				else
    				{
    					float t = ((float)x)/n;
    					long tt = (long)Math.ceil(t);
    					
    					long ex = i;
    					long ti = tt*n+ex;
    					
    					
    					if(ti<ansv)
    					{
    						//pw.println("** "+i);
    						ansg=i;
    						ansv=ti;
    					}
    					
    				}
    				
    				
    				
    			}
    			
    			pw.println(ansg+1);
    			*/
    			   
    			   
    			   
    		
    			   
    			   
    	
    			   
    			   /*ct=0;
    			
    			paths= new ArrayList[10];
    			adj = new ArrayList[4];
    			vis2 = new int[4];
    			
    			for(int i=0;i<4;i++)adj[i] = new ArrayList<Integer>();
    			   
    			for(int i=0;i<10;i++)paths[i] = new ArrayList<Integer>();
    			
    			adj[0].add(1);
    			adj[0].add(2);
    			adj[0].add(3);
    			
    			adj[1].add(3);
    			
    			adj[2].add(0);
    			adj[2].add(1);
    			
    			countPaths(2,3, new ArrayList<Integer>());
    			pw.println(ct);
    			   
    			for(int i=0;i<ct;i++)pw.println(paths[i]);
    			  */ 
    			   
    			   
    			   
    			   /*
    			   int n = sc.nextInt();
    			int m = sc.nextInt();
    			
    			int arr[] = new int[n];
    			
    			for(int i=0;i<n;i++)arr[i]=sc.nextInt();
    			
    			int req = n/m;
    			
    			int[] rem = new int[m];
    			
    			
    			HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
    			for(int i=0;i<n;i++)
    			{
    				rem[arr[i]%m]++;
    				
    			}
    			int li=-1;
    			long ans=0;
    			for(int i=0;i<m;i++)
    			{
    				if(rem[i]>=req)
    				{
    					rem[(i+1)%m]+=rem[i]-req;
    					ans+=(rem[i]-req);
    				}
    				else
    				{
    					li=i;
    					
    				}
    			}
    			
    			for(int i=0;i<li;i++)
    			{
    				if(rem[i]>=req)
    				{
    					rem[(i+1)%m]+=rem[i]-req;
    					ans+=(rem[i]-req);
    				}
    				else
    				{
    					li=i;
    					
    				}
    			}
    			pw.println(ans);
    			*/
    			
    			
    			
    			   //pw.println(pa);
    		/*	  NGE 
       		int[] sto = {100,80,60,70,60,75,85};
       		int n = sto.length;
       		
       		int[] spa = new int[n];
       		spa[0]=1;
       		
       		Stack<Integer> st = new Stack<Integer>();
       		st.push(0);
       		
       		for(int i=1;i<n;i++)
       		{
       			
       			while(!st.isEmpty()&&sto[st.peek()]<=sto[i])st.pop();
       			
       			spa[i]=(st.isEmpty())?i+1:i-st.peek();
       			st.push(i);
       			
       		}
    			  
       		
       		for(int i=0;i<n;i++)pw.print(sto[i]+" ");
    			   pw.println();
    			   for(int i=0;i<n;i++)pw.print(spa[i]+" ");
    			  
    			   
    			   int[] nge = new int[n];
    			   
    			   st.clear();
    			   Stack<Point> st2 = new Stack<Point>();
    			   st2.push(new Point(sto[0],0));
    			   
    			   for(int i=1;i<n;i++)
    			   {
    				   while(!st2.isEmpty()&&st2.peek().x<sto[i])
    				   {
    					   Point pop = st2.pop();
    					   nge[pop.y]=sto[i];
    				   }
    				   st2.push(new Point(sto[i],i));
    				   
    			   }
    			   
    			   while(!st2.isEmpty())
    			   {
    				   nge[st2.pop().y]=-1;
    			   }
    			  
    			   pw.println();
    			   for(int i=0;i<n;i++)pw.print(sto[i]+" ");
    			   pw.println();
    			   for(int i=0;i<n;i++)pw.print(nge[i]+" ");
    			 */ 
    			   
    			   /*  int r = 2000000000;
    			  pw.println(r);
    			int n = sc.nextInt();
    			int k = sc.nextInt();
    			int l = sc.nextInt();
    			int m = n*k;
    			int arr[] = new int[m];
    			
    			for(int i=0;i<m;i++)arr[i]=sc.nextInt();
    			
    			Arrays.sort(arr);
    			
    			int limit = l+arr[0];
    			int li=-1;
    			
    			for(int i=0;i<m;i++)
    			{
    				//pw.println(arr[i]);
    				if(arr[i]>limit)
    				{
    					//pw.println(arr[i]);
    					li=i; break;
    				}
    			}
    			//pw.println(limit+" "+li);
    			if(li==-1)li=n;
    			
    			int noofsmallest = li;
    			
    			if(noofsmallest<n)
    			{
    				pw.println(0);
    			}
    			else
    			{
    				li--;
    				long ans=0;
    				for(int i=0;i<n-1;i++)
    				{
    					ans+=(long)arr[li];
    					li--;
    				}
    				ans+=arr[0];
    				pw.println(ans);
    				
    			}
    			  */ 
    			   
    			   
    			   
    		
    			 
    			  
    			pw.close();  
    			   
    	   }
    		   
    		   
    		   
    		   static  class MyScanner 
    			{
    	
    			BufferedReader br;
    			StringTokenizer st;
    	
    			public MyScanner() 
    			{
    				br = new BufferedReader(new InputStreamReader(System.in));
    			}
    	
    			String next() 
    			{
    				
    				while (st == null || !st.hasMoreElements()) 
    				{
    					try 
    					{
    						st = new StringTokenizer(br.readLine());
    					} catch (IOException e) 
    					{
    						e.printStackTrace();
    					}
    				}
    				return st.nextToken();
    			}
    	
    			int nextInt() 
    			{
    				return Integer.parseInt(next());
    			}
    	
    			long nextLong() 
    			{
    				return Long.parseLong(next());
    			}
    	
    			double nextDouble() 
    			{
    				return Double.parseDouble(next());
    			}
    	
    			String nextLine()
    			{
    				String str = "";
    				try 
    				{
    					str = br.readLine();
    				} catch (IOException e) 
    				{
    					e.printStackTrace();
    				}
    				return str;
    			}
    	
    		}
    	
    		static MyScanner sc = new  MyScanner();
    		static PrintWriter pw = new PrintWriter(System.out, true);
    		
    		static class DisjointSet
    		{
    			int[] parent;
    			int[] rank;
    			int n;
    			
    			public DisjointSet(int x)
    			{
    				n=x;
    				parent = new int[x];
    				rank = new int[x];
    				
    				for(int i=0;i<n;i++)
    				{
    					parent[i]=i;
    				}
    				
    			}
    			
    			public int find(int x)
    			{
    				
    				if(parent[x]==x)
    					return x;
    				else 
    					return find(parent[x]);
    			}
    			
    			public void union(int i, int j)
    			{
    				int iroot = find(i);
    				int jroot = find(j);
    				
    				if(iroot==jroot)
    					return;
    				
    				if(rank[iroot]<rank[jroot])
    				{
    					parent[iroot]=jroot;
    					
    				}
    				else if(rank[jroot]<rank[iroot])
    				{
    					parent[jroot]=iroot;
    				}
    				else
    				{
    					parent[iroot]=jroot;
    					rank[jroot]++;
    					
    				}
    				
    				
    				
    				
    			}
    			
    			
    			
    			
    			
    		}
    	
    		
    	}  